angle limite pour le segment

Question

je dois limiter un angle il s'insère dans un segment. J'ai dessiné et des liens vers un diagramme ci-dessous pour mieux décrire ce que je suis après. Je suis en train de calculer cela pour un programme d'ordinateur, où j'ai un angle (pente), et un point (le pointeur de la souris). La distance ne m'importe pas, juste les angles. Si le point est dans b1 (zone verte), puis c'est très bien. Mais si le point est b2 ou b3 (rouge ou orange), alors l'angle devrait revenir à la limite de la zone verte (le long de la ligne s).

Diagram of my problem http://sandbox.adamharte.com/dump/trigdiagram.jpg

Le principal problème Je rencontre en essayant de se faire, est claquer l'angle du bon côté par exemple, Si le point est dans la zone rouge, alors l'angle doit être aligné sur l'angle s du côté rouge et vice versa.

Je suis également de la difficulté parce que s pourrait être un angle quelconque, alors je me fais trébuché parce que je ne peux pas faire quelque chose comme ceci:

si un (radians) est supérieur que s (radians), puis mis en un à la valeur de s

ou j'obtiendrai des erreurs lorsque l'angle entre zéro et 2Pi.

Alors, comment je travaille cela? Dois-je tout ramener à un point zéro ou quelque chose, puis le remettre lorsque j'ai fait mes calculs?

Merci d'avoir lu mon quêtes.

Answer 1

Premier code dans une fonction ATAN2(), pour calculer l'angle absolu du point par rapport au plan horizontal. Puis soustrayez l'angle de la pente. si le résultat est < 0 enclenchant à 0 et si le résultat est> 180 à 180. Le composant logiciel enfichable ajouter l'angle de la pente en arrière pour obtenir votre angle final

psi = (angle of slope) 
a = atan2(x,y) 
th = a-psi 
if(th<0) { th=0; } 
if(th>pi) { th=pi; } 
a = th+psi 

essayer.

Answer 2

Je devrais faire quelques suppositions puisque vous ne spécifiez pas comment vous définissez la pente. De toute façon, vous devriez être en mesure d'obtenir un thêta de l'équation.

Voici un exemple qui fait ce que vous avez besoin. Ce fut un défi amusant de le faire fonctionner et il devrait vous aider à démarrer. Remarque: une chose qui m'a aidé était toujours garder les angles entre -pi et pi. J'utilise aussi vector projection pour que la ligne tracée paraisse bien sur la pente.

package 
{ 
import flash.display.Graphics; 
import flash.display.Sprite; 
import flash.events.Event; 
import flash.events.MouseEvent; 
import flash.geom.Point; 

public class CircleSnap extends Sprite 
{ 
    private static const DEG_TO_RAD:Number = (Math.PI/180); 
    private static const RAD_TO_DEG:Number = (180/Math.PI); 

    private static const centerPoint:Point = new Point(200, 200); 
    private static const RADIUS:int = 100; 

    private var slope:Number; 

    private var circle:Sprite; 
    private var line:Sprite; 

    public function CircleSnap() 
    { 
     addEventListener(Event.ADDED_TO_STAGE, addedToStage); 
    } 

    private function addedToStage(event:Event):void 
    { 
     // choose a random slope (between -Math.PI to Math.PI) 
     slope = (Math.random()*Math.PI*2) - Math.PI; 

     // draw the circle 
     circle = makeColoredCircle(); 
     addChild(circle); 

     circle.x = centerPoint.x; 
     circle.y = centerPoint.y; 
     circle.rotation = slope * RAD_TO_DEG; 

     line = new Sprite(); 
     addChild(line); 

     stage.addEventListener(MouseEvent.MOUSE_MOVE, drawLine); 
    } 

    private function drawLine(event:MouseEvent):void 
    { 
     line.graphics.clear(); 

     // calculate the angle of the line 
     var lineAngle:Number = Math.atan2(
      stage.mouseY - centerPoint.y, 
      stage.mouseX - centerPoint.x); 

     var angleDiff:Number = (lineAngle - slope); 
     if(Math.abs(angleDiff) > Math.PI) 
     { 
      // wrap the angle between -pi and pi 
      var angleDir:int = angleDiff > 0 ? -1 : 1; 
      angleDiff = (Math.PI*2 - Math.abs(angleDiff)) * angleDir; 
     } 

     // assume we just draw to the mouse position 
     var destX:Number = stage.mouseX; 
     var destY:Number = stage.mouseY; 
     // if we are in the top area of the circle 
     if(angleDiff < 0) 
     { 
      // calculate the length 
      var xDiff:Number = stage.mouseX - centerPoint.x; 
      var yDiff:Number = stage.mouseY - centerPoint.y; 
      // we use Math.cos here to project the new line onto the slope 
      var len:Number = Math.cos(angleDiff) * Math.sqrt(xDiff*xDiff+yDiff*yDiff); 
      destX = Math.cos(slope) * len + centerPoint.x; 
      destY = Math.sin(slope) * len + centerPoint.y; 
     } 

     // draw the line 
     line.graphics.lineStyle(3, 0x00FFFF); 
     line.graphics.moveTo(centerPoint.x, centerPoint.y); 
     line.graphics.lineTo(destX, destY); 
    } 

    private function makeColoredCircle():Sprite 
    { 
     var circle:Sprite = new Sprite(); 
     var bottomHalf:Sprite = new Sprite(); 
     circle.addChild(bottomHalf); 
     bottomHalf.graphics.beginFill(0xFF0000); 
     halfCircle(bottomHalf.graphics, 0, 0, RADIUS); 
     var topLeftQuarter:Sprite = new Sprite(); 
     circle.addChild(topLeftQuarter); 
     topLeftQuarter.graphics.beginFill(0x00FF00); 
     quarterCircle(topLeftQuarter.graphics, 0, 0, RADIUS); 
     topLeftQuarter.rotation = 180 
     var topRightQuarter:Sprite = new Sprite(); 
     circle.addChild(topRightQuarter); 
     topRightQuarter.graphics.beginFill(0x0000FF); 
     quarterCircle(topRightQuarter.graphics, 0, 0, RADIUS); 
     topRightQuarter.rotation = -90; 
     return circle; 
    } 

    // found this here: http://actionsnippet.com/?p=1515 
    private function halfCircle(g:Graphics, x:Number,y:Number,r:Number):void 
    { 
     var c1:Number=r * (Math.SQRT2 - 1); 
     var c2:Number=r * Math.SQRT2/2; 
     g.moveTo(x+r,y); 
     g.curveTo(x+r,y+c1,x+c2,y+c2); 
     g.curveTo(x+c1,y+r,x,y+r); 
     g.curveTo(x-c1,y+r,x-c2,y+c2); 
     g.curveTo(x-r,y+c1,x-r,y); 
    } 

    // modified from halfCircle found here: http://actionsnippet.com/?p=1515 
    private function quarterCircle(g:Graphics, x:Number,y:Number,r:Number):void 
    { 
     var c1:Number=r * (Math.SQRT2 - 1); 
     var c2:Number=r * Math.SQRT2/2; 
     g.moveTo(x+r,y); 
     g.curveTo(x+r,y+c1,x+c2,y+c2); 
     g.curveTo(x+c1,y+r,x,y+r); 
     g.lineTo(x, y); 
    } 
} 

}