Mit UIPinchGestureRecognizer zu skalieren uiviews in eine einzige Richtung

Wenn ich das richtig verstehe ist deine Frage, Sie Streben an, dass die nicht-proportionale Skalierung auf der horizontalen und vertikalen Achse. In diesem Fall, die Sache kommt, um die Bereitstellung Ihrer Affin-Transformation:

  piece.transform = CGAffineTransformScale([piece transform], hScale, vScale);

mit unterschiedlichen Skalierungsfaktoren.

Einen Weg zu berechnen, ist die folgende:

1. definieren ivar in Ihrer Klasse zum speichern der lastTouchPosition;

2. in Ihrer Geste handler werden Sie etwas wie dieses:

   if ([gestureRecognizer state] == UIGestureRecognizerStateBegan){
   
      lastTouchPosition = [gestureRecognize locationInView:yourViewHere];
      hScale = 1;
      vScale = 1;
   
   } else if ([gestureRecognizer state] == UIGestureRecognizerStateBegan || [gestureRecognizer state] == UIGestureRecognizerStateChanged){
   
      CGPoint currentTouchLocation = [gestureRecognize locationInView:yourViewHere];
      CGPoint deltaMove = CGPointDistance(currentTouchLocation, lastTouchPosition);
      float distance = sqrt(deltaMove.x*deltaMove.x + deltaMove.y*deltaMove.y);
      hScale -= abs(deltaMove.x)/distance * (1-gestureRecognizer.scale);
      vScale -= abs(deltaMove.y)/distance * (1-gestureRecognizer.scale);
      piece.transform = CGAffineTransformScale([piece transform], hScale, vScale);
      [gestureRecognizer setScale:1];
   
      lastTouchPosition = currentTouchLocation;
   }

Alternative Art und Weise zu tun ist:

    if ([gestureRecognizer state] == UIGestureRecognizerStateBegan){

       lastTouchPosition = [gestureRecognize locationInView:yourViewHere];

    } else if ([gestureRecognizer state] == UIGestureRecognizerStateBegan || [gestureRecognizer state] == UIGestureRecognizerStateChanged){

       CGPoint currentTouchLocation = [gestureRecognize locationInView:yourViewHere];
       CGPoint deltaMove = CGPointDistance(currentTouchLocation, lastTouchPosition);
       float distance = sqrt(deltaMove.x*deltaMove.x + deltaMove.y*deltaMove.y);
       float hScale = 1 - abs(deltaMove.x)/distance * (1-gestureRecognizer.scale);
       float vScale = 1 - abs(deltaMove.y)/distance * (1-gestureRecognizer.scale);
       piece.transform = CGAffineTransformScale([piece transform], hScale, vScale);

       lastTouchPosition = currentTouchLocation;
    }

Diese nicht speichern, die bei jedem Durchlauf die aktuelle hFloat und vFloat und setzen stattdessen auf die Tatsache, dass die gestureRecognizer sammeln sich die gesamte Skala ändern. Es hat eine "absolute" zu berechnen, während die erste Implementierung stellt eine "relative" ein.

Beachten Sie, dass müssen Sie auch definieren CGPointDistance zur Berechnung der Entfernung zwischen zwei Berührungen, und wählen Sie, in welcher Ansicht sind Sie gehen, um zu verwenden, um die Entfernung zu berechnen (yourViewHere).

EDIT:

CGPoint CGPointDistance(CGPoint point1, CGPoint point2)
{
    return = CGPointMake(point2.x - point1.x, point2.y - point1.y);
};

EDIT2: über die Formel, die zum berechnen der Skalierung

Die Idee ist, die Berechnung der variation in der scale-Faktor und wenden Sie es auf die zwei Richtungen (x und y) entsprechend Ihrer relativen Variationen.

1. den Skalierungsfaktor delta ist: 1-gestureRecognizer.scale;

2. delta ist das, multipliziert mit einem Faktor, so dass es irgendwie proportional zu der Verschiebung entlang der horizontalen oder der vertikalen Achse; bei der Verschiebung null ist, wird der delta-Skala ist auch null, wenn der Hubraum gleich ist, die entlang der zwei Achsen, die Waage delta ist auch gleich entlang der zwei Achsen; ich beschloss, zu dividieren durch die distance, aber es gibt auch andere Möglichkeiten (wie die Division durch die Summe der beiden deltaMoves oder von der max von der deltaMoves, etc).

3. die eingestellte delta ist schließlich subtrahiert von der aktuellen Skalierung des Elements.

Erstellte ich eine benutzerdefinierte version einer UIPinchGestureRecognizer zu tun genau das, was du bist suchen für. Es nutzt die Steilheit der Linie zwischen den zwei Fingern, um zu bestimmen, die Richtung der Skala. Es hat 3 Arten: Vertikal; Horizontal; und Kombiniert(diagonal). Bitte Lesen Sie meine Hinweise auf der Unterseite.

-(void) scaleTheView:(UIPinchGestureRecognizer *)pinchRecognizer
    {
    if ([pinchRecognizer state] == UIGestureRecognizerStateBegan || [pinchRecognizer state] == UIGestureRecognizerStateChanged) {

    if ([pinchRecognizer numberOfTouches] > 1) {

        UIView *theView = [pinchRecognizer view];

        CGPoint locationOne = [pinchRecognizer locationOfTouch:0 inView:theView];
        CGPoint locationTwo = [pinchRecognizer locationOfTouch:1 inView:theView];
            NSLog(@"touch ONE  = %f, %f", locationOne.x, locationOne.y);
            NSLog(@"touch TWO  = %f, %f", locationTwo.x, locationTwo.y);
        [scalableView setBackgroundColor:[UIColor redColor]];

        if (locationOne.x == locationTwo.x) {
                //perfect vertical line
                //not likely, but to avoid dividing by 0 in the slope equation
            theSlope = 1000.0;
        }else if (locationOne.y == locationTwo.y) {
                //perfect horz line
                //not likely, but to avoid any problems in the slope equation
            theSlope = 0.0;
        }else {
            theSlope = (locationTwo.y - locationOne.y)/(locationTwo.x - locationOne.x);
        }

        double abSlope = ABS(theSlope);

        if (abSlope < 0.5) {
                    // Horizontal pinch - scale in the X
            [arrows setImage:[UIImage imageNamed:@"HorzArrows.png"]];
            arrows.hidden = FALSE;
                    //tranform.a  = X-axis
                NSLog(@"transform.A = %f", scalableView.transform.a);
                    //tranform.d  = Y-axis
                NSLog(@"transform.D = %f", scalableView.transform.d);

                    // if hit scale limit along X-axis then stop scale and show Blocked image
            if (((pinchRecognizer.scale > 1.0) && (scalableView.transform.a >= 2.0)) || ((pinchRecognizer.scale < 1.0) && (scalableView.transform.a <= 0.1))) {
                blocked.hidden = FALSE;
                arrows.hidden = TRUE;
            } else {
                        //scale along X-axis
                scalableView.transform = CGAffineTransformScale(scalableView.transform, pinchRecognizer.scale, 1.0);
                pinchRecognizer.scale = 1.0;
                blocked.hidden = TRUE;
                arrows.hidden = FALSE;
            }
        }else if (abSlope > 1.7) {
                    //Vertical pinch - scale in the Y
            [arrows setImage:[UIImage imageNamed:@"VerticalArrows.png"]];
            arrows.hidden = FALSE;
                NSLog(@"transform.A = %f", scalableView.transform.a);
                NSLog(@"transform.D = %f", scalableView.transform.d);

                    // if hit scale limit along Y-axis then don't scale and show Blocked image
            if (((pinchRecognizer.scale > 1.0) && (scalableView.transform.d >= 2.0)) || ((pinchRecognizer.scale < 1.0) && (scalableView.transform.d <= 0.1))) {
                blocked.hidden = FALSE;
                arrows.hidden = TRUE;
            } else {
                        //scale along Y-axis
                scalableView.transform = CGAffineTransformScale(scalableView.transform, 1.0, pinchRecognizer.scale);
                pinchRecognizer.scale = 1.0;
                blocked.hidden = TRUE;
                arrows.hidden = FALSE;
            }
        } else {
                    //Diagonal pinch - scale in both directions
            [arrows setImage:[UIImage imageNamed:@"CrossArrows.png"]];
            blocked.hidden = TRUE;
            arrows.hidden = FALSE;

                NSLog(@"transform.A = %f", scalableView.transform.a);
                NSLog(@"transform.D = %f", scalableView.transform.d);

                    //if we have hit any limit don't allow scaling
            if ((((pinchRecognizer.scale > 1.0) && (scalableView.transform.a >= 2.0)) || ((pinchRecognizer.scale < 1.0) && (scalableView.transform.a <= 0.1))) || (((pinchRecognizer.scale > 1.0) && (scalableView.transform.d >= 2.0)) || ((pinchRecognizer.scale < 1.0) && (scalableView.transform.d <= 0.1)))) {
                blocked.hidden = FALSE;
                arrows.hidden = TRUE;
            } else {
                        //scale in both directions
                scalableView.transform = CGAffineTransformScale(scalableView.transform, pinchRecognizer.scale, pinchRecognizer.scale);
                pinchRecognizer.scale = 1.0;
                blocked.hidden = TRUE;
                arrows.hidden = FALSE;
            }
        }  //else for diagonal pinch
    }  //if numberOfTouches
}  //StateBegan if

if ([pinchRecognizer state] == UIGestureRecognizerStateEnded || [pinchRecognizer state] == UIGestureRecognizerStateCancelled) {
    NSLog(@"StateEnded StateCancelled");
    [scalableView setBackgroundColor:[UIColor whiteColor]];
    arrows.hidden = TRUE;
    blocked.hidden = TRUE;
    }
}

Vergessen Sie nicht, das Protokoll auf den view-controller-header-Datei:

@interface WhiteViewController : UIViewController <UIGestureRecognizerDelegate>
{
IBOutlet UIView *scalableView;
IBOutlet UIView *mainView;
IBOutlet UIImageView *arrows;
IBOutlet UIImageView *blocked;
}
@property (strong, nonatomic) IBOutlet UIView *scalableView;
@property (strong, nonatomic) IBOutlet UIView *mainView;
@property (strong, nonatomic)IBOutlet UIImageView *arrows;
@property (strong, nonatomic)IBOutlet UIImageView *blocked;

-(void) scaleTheView:(UIPinchGestureRecognizer *)pinchRecognizer;
@end

Hinzufügen und die Erkennung in der viewDidLoad:

- (void)viewDidLoad
{ UIPinchGestureRecognizer *pinchGesture = [[UIPinchGestureRecognizer alloc] initWithTarget:self action:@selector(scaleTheView:)];
[pinchGesture setDelegate:self];
[mainView addGestureRecognizer:pinchGesture];

arrows.hidden = TRUE;
blocked.hidden = TRUE;
[scalableView setBackgroundColor:[UIColor whiteColor]];}

Dies ist für die Verwendung in der Hauptansicht zu erfassen, die Prise; und manipulieren einer zweiten Ansicht. Auf diese Weise können Sie noch skalieren, als die Ansicht wird kleiner. Sie können es ändern, um direkt zu reagieren, um die skalierbare Ansicht.

GRENZEN: ich willkürlich wählte die Anfangsgröße meiner Sicht ist so eine Skala-Grenzwert von 2,0 würde gleich Vollbild. Meine unteren Skala liegt bei 0.1.

USER-INTERAKTION: ich mess around mit viel Interaktion mit dem Benutzer Dinge wie das ändern der Ansicht der hintergrund-Farbe und das hinzufügen/ändern von Pfeilen über die Anzeige, um zu zeigen, Richtung. Es ist wichtig, um feedback zu geben, während die Skalierung Prozess, vor allem, wenn Sie die Richtungen ändern, wie diese codes ermöglicht.

BUG: Es gibt einen bug in apples UIPinchGestureRecognizer. Es registriert UIGestureRecognizerStateBegan mit dem Hauch von 2 Fingern, wie man es erwarten würde. Aber wenn es einmal in StateBegan oder StateChanged können Sie heben mit einem finger, und der Staat bleibt. Er bewegt sich nicht zu StateEnded oder StateCancelled, bis BEIDE Finger gehoben werden. Dies erzeugt einen Fehler in meinem code und viele Kopfschmerzen! Wenn die numberOfTouches > 1 behebt es.

ZUKUNFT: Sie können die slope-Einstellungen, um die Waage in eine Richtung, oder nur 2. Wenn Sie fügen Sie die Pfeile Bildern können Sie sehen, wie Sie ändern, wie Sie drehen Sie Ihren Finger.