mitk::Point2D mitk::PlanarDoubleEllipse::ApplyControlPointConstraints(unsigned int index, const Point2D& point) { if (index == 2 && !m_ConstrainCircle) { Point2D centerPoint = this->GetControlPoint(0); Vector2D outerMajorVector = this->GetControlPoint(1) - centerPoint; Vector2D minorDirection; minorDirection[0] = outerMajorVector[1]; minorDirection[1] = -outerMajorVector[0]; minorDirection.Normalize(); double outerMajorRadius = outerMajorVector.GetNorm(); double innerMajorRadius = (this->GetControlPoint(3) - centerPoint).GetNorm(); ScalarType radius = std::max(outerMajorRadius - innerMajorRadius, std::min(centerPoint.EuclideanDistanceTo(point), outerMajorRadius)); return centerPoint + minorDirection * radius; } else if (index == 3 && !m_ConstrainThickness) { Point2D centerPoint = this->GetControlPoint(0); Vector2D outerMajorVector = this->GetControlPoint(1) - centerPoint; double outerMajorRadius = outerMajorVector.GetNorm(); double outerMinorRadius = (this->GetControlPoint(2) - centerPoint).GetNorm(); ScalarType radius = std::max(outerMajorRadius - outerMinorRadius, std::min(centerPoint.EuclideanDistanceTo(point), outerMajorRadius)); outerMajorVector.Normalize(); return centerPoint - outerMajorVector * radius; } return point; }
void TextureTest::ProcessEvent(SDL_Event* event) { switch(event->type) { case SDL_MOUSEBUTTONDOWN: { if(event->button.button == 4) { } else if(event->button.button == 5) { } break; } case SDL_KEYDOWN: { if(event->key.keysym.sym == SDLK_UP) { Vector2D oldSteer = v->GetVelocity(); Vector2D temp = v->GetVelocity(); temp.Normalize(); v->SetVelocity(oldSteer+temp*16); //v->SetHeading(v->GetVelocity()); } if(event->key.keysym.sym == SDLK_DOWN) { Vector2D oldSteer = v->GetVelocity(); Vector2D temp = v->GetVelocity(); temp.Normalize(); v->SetVelocity(oldSteer-temp*163); } if(event->key.keysym.sym == SDLK_LEFT) { Matrix2D mat; //Vector2D vec = v->GetVelocity(); Vector2D vecH = v->GetVelocity(); //Vec2DRotateAroundO(vecH,angle); mat.Rotate(angle); // //mat.Rotate(angle); mat.TransformVector(vecH); // / mat.TransformVector(vecH); // //v->SetVelocity(vec); // v->RotateHeadingToFacePosition(vecH); //v->SetSteeringForce(vecH); v->SetVelocity(vecH); angle=0.07; } break; } //case SDL_KEYUP } }
void Physics::TestCollision(Circle *a, Circle *b) { Vector2D n = (b->GetCentroidPosition() - a->GetCentroidPosition()); double depth = a->radius + b->radius - n.GetLength(); if (depth < 0) return; n.Normalize(); constraints.push_back(new Contact(a, b, a->GetCentroidPosition() + n * a->radius, n, depth)); }
Vector2D Slerp(const Vector2D &a, const Vector2D &b, Float t) { Float dot = Math::WrapFloat(Dot(a, b), -1.0f, 1.0f); Float theta = acos(dot) * t; Vector2D relativeVec = b - (a * dot); relativeVec.Normalize(); return ((a*cos(theta)) + (relativeVec*sin(theta))); }
void Shape::resolveCollision( Shape & shape ) { Vector2D delta = position - shape.position; float d = delta.Length(); Vector2D mtd = delta * ( ( ( getRadius() + shape.getRadius() ) - d ) / d ); float im1 = 1 / getMass(); float im2 = 1 / shape.getMass(); // speed Vector2D v = velocity - shape.velocity; float vn = v * (mtd.Normalize()); // intersecting but moving away if ( vn > 0.0f ) return; // impulse float i = (-(1.0f + RESTITUTION) * vn ) / ( im1 + im2 ); Vector2D impulse = mtd * i; // momentum velocity += impulse * im1; shape.velocity -= impulse * im1; }
void Vector2D::ProjToLine (const Vector2D &rclPt, const Vector2D &rclLine) { double l = rclLine.Length(); double t1 = (rclPt * rclLine) / l; Vector2D clNormal = rclLine; clNormal.Normalize(); clNormal.Scale(t1); *this = clNormal; }
mitk::Point2D mitk::PlanarCircle::ApplyControlPointConstraints(unsigned int index, const Point2D &point) { if ( this->GetPlaneGeometry() == nullptr ) { return point; } Point2D indexPoint; this->GetPlaneGeometry()->WorldToIndex( point, indexPoint ); BoundingBox::BoundsArrayType bounds = this->GetPlaneGeometry()->GetBounds(); if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; } if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; } if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; } if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; } Point2D constrainedPoint; this->GetPlaneGeometry()->IndexToWorld( indexPoint, constrainedPoint ); if(m_MinMaxRadiusContraintsActive) { if( index != 0) { const Point2D ¢erPoint = this->GetControlPoint(0); double euclideanDinstanceFromCenterToPoint1 = centerPoint.EuclideanDistanceTo(point); Vector2D vectorProjectedPoint; vectorProjectedPoint = point - centerPoint; vectorProjectedPoint.Normalize(); if( euclideanDinstanceFromCenterToPoint1 > m_MaxRadius ) { vectorProjectedPoint *= m_MaxRadius; constrainedPoint = centerPoint; constrainedPoint += vectorProjectedPoint; } else if( euclideanDinstanceFromCenterToPoint1 < m_MinRadius ) { vectorProjectedPoint *= m_MinRadius; constrainedPoint = centerPoint; constrainedPoint += vectorProjectedPoint; } } } return constrainedPoint; }
TEST(vec2d, norm) { Vector2D testingVector = Vector2D(); testingVector.x = 1; testingVector.y = 0; testingVector.Magnitude(); testingVector.Normalize(); EXPECT_FLOAT_EQ(1.f, testingVector.x); EXPECT_FLOAT_EQ(0.f, testingVector.y); }
void mitk::PlanarEllipse::GeneratePolyLine() { // clear the PolyLine-Contrainer, it will be reconstructed soon enough... this->ClearPolyLines(); const Point2D ¢erPoint = GetControlPoint( 0 ); const Point2D &boundaryPoint1 = GetControlPoint( 1 ); const Point2D &boundaryPoint2 = GetControlPoint( 2 ); Vector2D dir = boundaryPoint1 - centerPoint; dir.Normalize(); vnl_matrix_fixed<float, 2, 2> rot; // differentiate between clockwise and counterclockwise rotation int start = 0; int end = 64; if (dir[1]<0) { dir[0] = -dir[0]; start = -32; end = 32; } // construct rotation matrix to align ellipse with control point vector rot[0][0] = dir[0]; rot[1][1] = rot[0][0]; rot[1][0] = sin(acos(rot[0][0])); rot[0][1] = -rot[1][0]; double radius1 = centerPoint.EuclideanDistanceTo( boundaryPoint1 ); double radius2 = centerPoint.EuclideanDistanceTo( boundaryPoint2 ); // Generate poly-line with 64 segments for ( int t = start; t < end; ++t ) { double alpha = (double) t * vnl_math::pi / 32.0; // construct the new polyline point ... vnl_vector_fixed< float, 2 > vec; vec[0] = radius1 * cos( alpha ); vec[1] = radius2 * sin( alpha ); vec = rot*vec; Point2D polyLinePoint; polyLinePoint[0] = centerPoint[0] + vec[0]; polyLinePoint[1] = centerPoint[1] + vec[1]; // ... and append it to the PolyLine. // No extending supported here, so we can set the index of the PolyLineElement to '0' AppendPointToPolyLine( 0, PolyLineElement( polyLinePoint, 0 ) ); } AppendPointToPolyLine( 1, PolyLineElement( centerPoint, 0 ) ); AppendPointToPolyLine( 1, PolyLineElement( GetControlPoint( 3 ), 0 ) ); }
void mitk::GizmoInteractor::RotateAroundAxis(StateMachineAction*, InteractionEvent* interactionEvent) { auto positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent); if(positionEvent == NULL) { return; } Vector2D originalVector = m_InitialClickPosition2D - m_InitialGizmoCenter2D; Vector2D currentVector = positionEvent->GetPointerPositionOnScreen() - m_InitialGizmoCenter2D; originalVector.Normalize(); currentVector.Normalize(); double angle_rad = std::atan2(currentVector[1], currentVector[0]) - std::atan2(originalVector[1], originalVector[0]); ApplyRotationToManipulatedObject(vtkMath::DegreesFromRadians(angle_rad)); RenderingManager::GetInstance()->ForceImmediateUpdateAll(); }
void IFSMCowFlee::Calculate(MovingEntity* entity, Instance* instance){ Rabbit* target = instance->GetRabbit(); Vector2D newHeading = (entity->GetPosition() - target->GetPosition()); newHeading.Normalize(); entity->SetHeading(newHeading); entity->Move(0.0f); }
bool Sector::Intersects(const Vector2D& position) const { Vector2D l(this->GetPosition() - position); if(l.GetLength() > GetRadius()) return false; if(Math::IsEqual(l.GetLength(), 0.0)) return true; Vector2D sF = Vector2D::GetFacingVector(this->GetArcCenter(), this->GetPosition()); Vector2D sF_n(sF.Normalize()); Vector2D P_to_S(l.Normalize()); double angle = std::acos(Vector2D::DotProduct(sF_n, P_to_S)); return (angle <= GetTheta() / 2.0); }
void DumbTank::Update(float deltaTime, SDL_Event e) { //This is a dumb tank. Do NOT copy this approach. //Did we see a tank? if(mTanksICanSee.size() == 0) { ChangeState(TANKSTATE_IDLE); //If there are no visible tanks, then keep moving. //Check if we reached position before turning. if(mPosition.y < mPosition1.y && mHeading.y != -1.0f) { mHeading = Vector2D(0.0f, -1.0f); mRotationAngle = 180.0f; mVelocity = Vector2D(); return; } else if(mPosition.y > mPosition2.y && mHeading.y != 1.0f) { mHeading = Vector2D(0.0f, 1.0f); mRotationAngle = 0.0f; mVelocity = Vector2D(); return; } else { //Move if we are facing the correct direction. mCurrentSpeed -= kSpeedIncrement*deltaTime; if(mCurrentSpeed < -GetMaxSpeed()) mCurrentSpeed = -GetMaxSpeed(); } } else { //Rotate man to face enemy tank. Vector2D toTarget = mTanksICanSee[0]->GetCentralPosition()-GetCentralPosition(); toTarget.Normalize(); double dot = toTarget.Dot(mManFireDirection); if(dot < 0.95f) RotateManByRadian(kManTurnRate, -1, deltaTime); //Otherwise stop moving and fire at the visible tank. mVelocity = Vector2D(); ChangeState(TANKSTATE_MANFIRE); } BaseTank::Update(deltaTime, e); }
void BaseTank::Rebound(Vector2D position) { //DEBUG: Alert on colliding. //cout << "Collision" << endl; //We need to rebound, but which direction? Vector2D newHeading = GetCentralPosition()-position; newHeading.Normalize(); //Flip the y coordinate because of the 0,0 position of SDL. newHeading.y *= -1.0f; //Set new velocity. mVelocity = newHeading*-kReboundSpeed; //Cut the speed. mCurrentSpeed = 0.0f; }
void IFSMCowFindGun::Calculate(MovingEntity* entity, Instance* instance){ Gun* target = instance->GetGun(); if (entity->GetPosition().DistanceBetween(target->GetPosition()) <= CATCH_DISTANCE) { //switch states printf("[Cow] found the Gun!\n"); entity->SetState(new IFSMCowHide()); instance->ResetEntities(false, false, false, true); return; } Vector2D newHeading = (target->GetPosition() - entity->GetPosition()); newHeading.Normalize(); entity->SetHeading(newHeading); entity->Move(0.0f); }
Vector2D ANCFBeamBE2D::GetInplaneUnitVector2DD(const double& p_loc) const { Vector2D rx = GetPosx2DD(p_loc); rx.Normalize(); return Vector2D(-rx(2), rx(1)); };
Vector2D Nlerp(const Vector2D &a, const Vector2D &b, Float t) { Vector2D v; Lerp(a, b, t, &v); v.Normalize(); return v; }
Vector2D Vector2D::DirectionVectorBetweenTwoPoints(const Vector2D &v1, const Vector2D & v2) { Vector2D vec = Vector2D(v2.x-v1.x,v2.y-v1.y); return vec.Normalize(); }
void DrawRain( void ) { if (FirstChainDrip.p_Next == NULL) return; // no drips to draw float visibleHeight = Rain.globalHeight - SNOWFADEDIST; // usual triapi stuff HSPRITE hsprTexture; if( Rain.weatherMode == 0 ) hsprTexture = LoadSprite("sprites/effects/rain.spr"); else hsprTexture = LoadSprite("sprites/effects/snowflake.spr"); const model_s *pTexture = gEngfuncs.GetSpritePointer(hsprTexture); gEngfuncs.pTriAPI->SpriteTexture( (struct model_s *)pTexture, 0 ); gEngfuncs.pTriAPI->RenderMode( kRenderTransAdd ); gEngfuncs.pTriAPI->CullFace( TRI_NONE ); // go through drips list cl_drip* Drip = FirstChainDrip.p_Next; cl_entity_t *player = gEngfuncs.GetLocalPlayer(); if ( Rain.weatherMode == 0 ) // draw rain { while (Drip != NULL) { cl_drip* nextdDrip = Drip->p_Next; Vector2D toPlayer; toPlayer.x = player->origin[0] - Drip->origin[0]; toPlayer.y = player->origin[1] - Drip->origin[1]; toPlayer = toPlayer.Normalize(); toPlayer.x *= DRIP_SPRITE_HALFWIDTH; toPlayer.y *= DRIP_SPRITE_HALFWIDTH; float shiftX = (Drip->xDelta / DRIPSPEED) * DRIP_SPRITE_HALFHEIGHT; float shiftY = (Drip->yDelta / DRIPSPEED) * DRIP_SPRITE_HALFHEIGHT; // --- draw triangle -------------------------- gEngfuncs.pTriAPI->Color4f( 1.0, 1.0, 1.0, Drip->alpha ); gEngfuncs.pTriAPI->Begin( TRI_TRIANGLES ); gEngfuncs.pTriAPI->TexCoord2f( 0, 0 ); gEngfuncs.pTriAPI->Vertex3f( Drip->origin[0]-toPlayer.y - shiftX, Drip->origin[1]+toPlayer.x - shiftY,Drip->origin[2] + DRIP_SPRITE_HALFHEIGHT ); gEngfuncs.pTriAPI->TexCoord2f( 0.5, 1 ); gEngfuncs.pTriAPI->Vertex3f( Drip->origin[0] + shiftX, Drip->origin[1] + shiftY, Drip->origin[2]-DRIP_SPRITE_HALFHEIGHT ); gEngfuncs.pTriAPI->TexCoord2f( 1, 0 ); gEngfuncs.pTriAPI->Vertex3f( Drip->origin[0]+toPlayer.y - shiftX, Drip->origin[1]-toPlayer.x - shiftY, Drip->origin[2]+DRIP_SPRITE_HALFHEIGHT); gEngfuncs.pTriAPI->End(); // --- draw triangle end ---------------------- Drip = nextdDrip; } } else // draw snow { vec3_t normal; gEngfuncs.GetViewAngles((float*)normal); float matrix[3][4]; AngleMatrix (normal, matrix); // calc view matrix while (Drip != NULL) { cl_drip* nextdDrip = Drip->p_Next; matrix[0][3] = Drip->origin[0]; // write origin to matrix matrix[1][3] = Drip->origin[1]; matrix[2][3] = Drip->origin[2]; // apply start fading effect float alpha = (Drip->origin[2] <= visibleHeight) ? Drip->alpha : ((Rain.globalHeight - Drip->origin[2]) / (float)SNOWFADEDIST) * Drip->alpha; // --- draw quad -------------------------- gEngfuncs.pTriAPI->Color4f( 1.0, 1.0, 1.0, alpha ); gEngfuncs.pTriAPI->Begin( TRI_QUADS ); gEngfuncs.pTriAPI->TexCoord2f( 0, 0 ); SetPoint(0, SNOW_SPRITE_HALFSIZE ,SNOW_SPRITE_HALFSIZE, matrix); gEngfuncs.pTriAPI->TexCoord2f( 0, 1 ); SetPoint(0, SNOW_SPRITE_HALFSIZE ,-SNOW_SPRITE_HALFSIZE, matrix); gEngfuncs.pTriAPI->TexCoord2f( 1, 1 ); SetPoint(0, -SNOW_SPRITE_HALFSIZE ,-SNOW_SPRITE_HALFSIZE, matrix); gEngfuncs.pTriAPI->TexCoord2f( 1, 0 ); SetPoint(0, -SNOW_SPRITE_HALFSIZE ,SNOW_SPRITE_HALFSIZE, matrix); gEngfuncs.pTriAPI->End(); // --- draw quad end ---------------------- Drip = nextdDrip; } } }
void mitk::PlanarDoubleEllipse::GeneratePolyLine() { this->ClearPolyLines(); Point2D centerPoint = this->GetControlPoint(0); Point2D outerMajorPoint = this->GetControlPoint(1); Vector2D direction = outerMajorPoint - centerPoint; direction.Normalize(); const ScalarType deltaAngle = vnl_math::pi / (m_NumberOfSegments / 2); int start = 0; int end = m_NumberOfSegments; if (direction[1] < 0.0) { direction[0] = -direction[0]; end = m_NumberOfSegments / 2; start = -end; } vnl_matrix_fixed<mitk::ScalarType, 2, 2> rotation; rotation[1][0] = std::sin(std::acos(direction[0])); rotation[0][0] = direction[0]; rotation[1][1] = direction[0]; rotation[0][1] = -rotation[1][0]; ScalarType outerMajorRadius = centerPoint.EuclideanDistanceTo(outerMajorPoint); ScalarType outerMinorRadius = centerPoint.EuclideanDistanceTo(this->GetControlPoint(2)); ScalarType innerMajorRadius = centerPoint.EuclideanDistanceTo(this->GetControlPoint(3)); ScalarType innerMinorRadius = innerMajorRadius - (outerMajorRadius - outerMinorRadius); ScalarType angle; ScalarType cosAngle; ScalarType sinAngle; vnl_vector_fixed<mitk::ScalarType, 2> vector; Point2D point; for (int i = start; i < end; ++i) { angle = i * deltaAngle; cosAngle = std::cos(angle); sinAngle = std::sin(angle); vector[0] = outerMajorRadius * cosAngle; vector[1] = outerMinorRadius * sinAngle; vector = rotation * vector; point[0] = centerPoint[0] + vector[0]; point[1] = centerPoint[1] + vector[1]; this->AppendPointToPolyLine(0, point); vector[0] = innerMajorRadius * cosAngle; vector[1] = innerMinorRadius * sinAngle; vector = rotation * vector; point[0] = centerPoint[0] + vector[0]; point[1] = centerPoint[1] + vector[1]; this->AppendPointToPolyLine(1, point); } }
void mitk::SurfaceGLMapper2D::PaintCells(mitk::BaseRenderer* renderer, vtkPolyData* contour, const PlaneGeometry* worldGeometry, const DisplayGeometry* displayGeometry, vtkLinearTransform * vtktransform, vtkLookupTable *lut, vtkPolyData* original3DObject) { // deprecated settings bool usePointData = false; bool useCellData = false; this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", useCellData, renderer); bool scalarVisibility = false; this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility, renderer); if(scalarVisibility) { VtkScalarModeProperty* scalarMode; if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer)) { if( (scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA) || (scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT) ) { usePointData = true; } if(scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA) { useCellData = true; } } else { usePointData = true; } } vtkPoints *vpoints = contour->GetPoints(); vtkDataArray *vpointscalars = contour->GetPointData()->GetScalars(); vtkCellArray *vlines = contour->GetLines(); vtkDataArray* vcellscalars = contour->GetCellData()->GetScalars(); Point3D p; Point2D p2d, last; int i, j; int numberOfLines = vlines->GetNumberOfCells(); glLineWidth( m_LineWidth ); glBegin (GL_LINES); glColor4fv(m_LineColor); double distanceSinceLastNormal(0.0); vlines->InitTraversal(); for(i=0;i<numberOfLines;++i) { vtkIdType *cell(NULL); vtkIdType cellSize(0); double vp[3]; vlines->GetNextCell(cellSize, cell); vpoints->GetPoint(cell[0], vp); //take transformation via vtktransform into account vtktransform->TransformPoint(vp, vp); vtk2itk(vp, p); //convert 3D point (in mm) to 2D point on slice (also in mm) worldGeometry->Map(p, p2d); //convert point (until now mm and in world coordinates) to display coordinates (units ) displayGeometry->WorldToDisplay(p2d, p2d); last=p2d; for(j=1; j<cellSize; ++j) { vpoints->GetPoint(cell[j], vp); Point3D originalPoint; vtk2itk(vp, originalPoint); //take transformation via vtktransform into account vtktransform->TransformPoint(vp, vp); vtk2itk(vp, p); //convert 3D point (in mm) to 2D point on slice (also in mm) worldGeometry->Map(p, p2d); //convert point (until now mm and in world coordinates) to display coordinates (units ) displayGeometry->WorldToDisplay(p2d, p2d); double color[3]; if (useCellData && vcellscalars != NULL ) { // color each cell according to cell data lut->GetColor( vcellscalars->GetComponent(i,0),color); glColor3f(color[0],color[1],color[2]); glVertex2f(last[0], last[1]); glVertex2f(p2d[0], p2d[1]); } else if (usePointData && vpointscalars != NULL ) { lut->GetColor( vpointscalars->GetComponent(cell[j-1],0),color); glColor3f(color[0],color[1],color[2]); glVertex2f(last[0], last[1]); lut->GetColor( vpointscalars->GetComponent(cell[j],0),color); glColor3f(color[0],color[1],color[2]); glVertex2f(p2d[0], p2d[1]); } else { glVertex2f(last[0], last[1]); glVertex2f(p2d[0], p2d[1]); // draw normals ? if (m_DrawNormals && original3DObject) { distanceSinceLastNormal += sqrt((p2d[0]-last[0])*(p2d[0]-last[0]) + (p2d[1]-last[1])*(p2d[1]-last[1])); if (distanceSinceLastNormal >= 5.0) { distanceSinceLastNormal = 0.0; vtkPointData* pointData = original3DObject->GetPointData(); if (!pointData) break; vtkDataArray* normalsArray = pointData->GetNormals(); if (!normalsArray) break; // find 3D point closest to the currently drawn point double distance(0.0); vtkIdType closestPointId = m_PointLocator->FindClosestPoint(originalPoint[0], originalPoint[1], originalPoint[2], distance); if (closestPointId >= 0) { // find normal of 3D object at this 3D point double* normal = normalsArray->GetTuple3(closestPointId); double transformedNormal[3]; vtktransform->TransformNormal(normal, transformedNormal); Vector3D normalITK; vtk2itk(transformedNormal, normalITK); normalITK.Normalize(); // calculate a point (point from the cut 3D object) + (normal vector of closest point) Point3D tip3D = p + normalITK; // map this point into our 2D coordinate system Point2D tip2D; worldGeometry->Map(tip3D, tip2D); displayGeometry->WorldToDisplay(tip2D, tip2D); // calculate 2D vector from point to point+normal, normalize it to standard length Vector2D tipVectorGLFront = tip2D - p2d; tipVectorGLFront.Normalize(); tipVectorGLFront *= m_FrontNormalLengthInPixels; Vector2D tipVectorGLBack = p2d - tip2D; tipVectorGLBack.Normalize(); tipVectorGLBack *= m_BackNormalLengthInPixels; Point2D tipPoint2D = p2d + tipVectorGLFront; Point2D backTipPoint2D = p2d + tipVectorGLBack; // draw normalized mapped normal vector glColor4f(m_BackSideColor[0], m_BackSideColor[1], m_BackSideColor[2], m_BackSideColor[3]); // red backside glVertex2f(p2d[0], p2d[1]); glVertex2f(tipPoint2D[0], tipPoint2D[1]); glColor4f(m_FrontSideColor[0], m_FrontSideColor[1], m_FrontSideColor[2], m_FrontSideColor[3]); // green backside glVertex2f(p2d[0], p2d[1]); glVertex2f(backTipPoint2D[0], backTipPoint2D[1]); glColor4fv(m_LineColor); // back to line color } } } } last=p2d; } } glEnd(); glLineWidth(1.0); }
bool mitk::PlanarDoubleEllipse::SetControlPoint(unsigned int index, const Point2D& point, bool createIfDoesNotExist) { switch (index) { case 0: { Point2D centerPoint = this->GetControlPoint(0); Vector2D vector = point - centerPoint; Superclass::SetControlPoint(0, point, createIfDoesNotExist); Superclass::SetControlPoint(1, this->GetControlPoint(1) + vector, createIfDoesNotExist); Superclass::SetControlPoint(2, this->GetControlPoint(2) + vector, createIfDoesNotExist); Superclass::SetControlPoint(3, this->GetControlPoint(3) + vector, createIfDoesNotExist); break; } case 1: { Vector2D vector = point - this->GetControlPoint(1); Superclass::SetControlPoint(1, point, createIfDoesNotExist); Point2D centerPoint = this->GetControlPoint(0); Vector2D outerMajorVector = point - centerPoint; Vector2D outerMinorVector; outerMinorVector[0] = outerMajorVector[1]; outerMinorVector[1] = -outerMajorVector[0]; if (!m_ConstrainCircle) { outerMinorVector.Normalize(); outerMinorVector *= centerPoint.EuclideanDistanceTo(this->GetControlPoint(2)); } Superclass::SetControlPoint(2, centerPoint + outerMinorVector, createIfDoesNotExist); Vector2D innerMajorVector = outerMajorVector; if (!m_ConstrainThickness) { innerMajorVector.Normalize(); innerMajorVector *= centerPoint.EuclideanDistanceTo(this->GetControlPoint(3) - vector); } Superclass::SetControlPoint(3, centerPoint - innerMajorVector, createIfDoesNotExist); break; } case 2: { m_ConstrainCircle = false; Superclass::SetControlPoint(2, point, createIfDoesNotExist); break; } case 3: { m_ConstrainThickness = false; Superclass::SetControlPoint(3, point, createIfDoesNotExist); break; } default: return false; } return true; }