sf::FloatRect NSpriteComponent::getBounds() const { sf::FloatRect r = getFinalTransform().transformRect(mSprite.getLocalBounds()); r.left -= getOrigin().x; r.top -= getOrigin().y; return r; }
float Obstacle::getDistanceFromObject(Obstacle testObj) { float distance = ( sqrt( (testObj.getOrigin().x-getOrigin().x)*(testObj.getOrigin().x-getOrigin().x) + (testObj.getOrigin().y-getOrigin().y)*(testObj.getOrigin().y-getOrigin().y) + (testObj.getOrigin().z-getOrigin().z)*(testObj.getOrigin().z-getOrigin().z) )); return distance; }
unsigned long myPlacement::getHPWL(myNet* net) { unsigned long total = 0.0; unsigned long pinsNum = net->getNumTerms(); vector<InstTerm>& instTerm = net->getTerms(); if (instTerm.size() < 2) { return 0; } myPoint origin1 = getOrigin(instTerm[0]); long minX = origin1.coordX(); long minY = origin1.coordY(); long maxX = minX; long maxY = minY; for (unsigned long tId = 1; tId < pinsNum; tId++) { myPoint origin = getOrigin(instTerm[tId]); if (origin.coordX() > maxX) { maxX = origin.coordX(); } if (origin.coordX() <= minX) { minX = origin.coordX(); } if (origin.coordY() > maxY) { maxY = origin.coordY(); } if (origin.coordY() <= minY) { minY = origin.coordY(); } } total = (maxX + maxY - minX - minY); return total; }
DECLARE_EXPORT ItemDistribution::~ItemDistribution() { // Delete the association from the related objects if (getOrigin()) getOrigin()->origins.erase(this); if (getDestination()) getDestination()->destinations.erase(this); // Delete all owned distribution operations while (firstOperation) delete firstOperation; // Unlink from previous item if (it) { if (it->firstItemDistribution == this) // Remove from head it->firstItemDistribution = next; else { // Remove from middle ItemDistribution *j = it->firstItemDistribution; while (j->next && j->next != this) j = j->next; if (j) j->next = next; else throw LogicException("Corrupted ItemDistribution list"); } } // Trigger level and cluster recomputation HasLevel::triggerLazyRecomputation(); }
LLVector3 LLViewerCamera::roundToPixel(const LLVector3 &pos_agent) { F32 dist = (pos_agent - getOrigin()).magVec(); // Convert to screen space and back, preserving the depth. LLCoordGL screen_point; if (!projectPosAgentToScreen(pos_agent, screen_point, FALSE)) { // Off the screen, just return the original position. return pos_agent; } LLVector3 ray_dir; projectScreenToPosAgent(screen_point.mX, screen_point.mY, &ray_dir); ray_dir -= getOrigin(); ray_dir.normVec(); LLVector3 pos_agent_rounded = getOrigin() + ray_dir*dist; /* LLVector3 pixel_x, pixel_y; getPixelVectors(pos_agent_rounded, pixel_y, pixel_x); pos_agent_rounded += 0.5f*pixel_x, 0.5f*pixel_y; */ return pos_agent_rounded; }
int intersect( const gtl::Vec3<Type>& V0, const gtl::Vec3<Type>& V1, const gtl::Vec3<Type>& V2, gtl::Vec3<Type>& I ) const { Vec3<Type> u, v, n; // triangle vectors Vec3<Type> dir, w0, w; // ray vectors Type r, a, b; // params to calc ray-plane intersect // get triangle edge vectors and plane normal u = V1 - V0; v = V2 - V0; n = u.cross(v); if (n == Vec3<Type>(0, 0, 0)) // triangle is degenerate return -1; // do not deal with this case dir = getDirection(); // ray direction vector w0 = getOrigin() - V0; a = -( n.dot(w0) ); b = n.dot(dir); if (fabs(b) < 0.00000001) { // ray is parallel to triangle plane if (a == 0) // ray lies in triangle plane return 2; else return 0; // ray disjoint from plane } // get intersect point of ray with triangle plane r = a / b; if (r < 0.0) // ray goes away from triangle return 0; // => no intersect // for a segment, also test if (r > 1.0) => no intersect I = getOrigin() + r * dir; // intersect point of ray and plane //// is I inside T? Type uu, uv, vv, wu, wv, D; uu = u.dot(u); uv = u.dot(v); vv = v.dot(v); w = I - V0; wu = w.dot(u); wv = w.dot(v); D = uv * uv - uu * vv; // get and test parametric coords Type s, t; s = (uv * wv - vv * wu) / D; if (s < 0.0 || s > 1.0) // I is outside T return 0; t = (uv * wu - uu * wv) / D; if (t < 0.0 || (s + t) > 1.0) // I is outside T return 0; return 1; // I is in T }
Vector3 Ray::planeIntersect() { float s = -getOrigin().z / getDirection().z; Vector3 worldPos(0, 0, 0); worldPos.x = getOrigin().x + getDirection().x*s; worldPos.y = getOrigin().y + getDirection().y*s; worldPos.z = 0; return worldPos; }
Rect Shape::getWorldRect(void) { Rect r = mBoundingBox; r.left += getOrigin().x; r.right += getOrigin().x; r.top += getOrigin().y; r.bottom += getOrigin().y; return r; }
void SnowMountain::display(GLuint texture) { glPushMatrix(); glTranslatef(getOrigin().x,getOrigin().y,getOrigin().z); glBindTexture(GL_2D_TEXTURE,texture); glBegin(GL_POLYGON);//build path glEnd(); glPopMatrix(); }
TEST_F(LensTest, parallel_rays_should_pass_through_the_focal_point) { Ray rays[]{Ray{{1, 2, 0}, DIR_Z}, Ray{{-3, 4, 1}, DIR_Z}, Ray{{4, 1, -3}, DIR_Z}}; for (auto& ray : rays) { auto refracted = lens.refract(ray); EXPECT_THAT(refracted, RayPassesThrough(FOCAL_POINT, EPS)); EXPECT_NEAR(ray.getOrigin()[0], refracted.getOrigin()[0], EPS); EXPECT_NEAR(ray.getOrigin()[1], refracted.getOrigin()[1], EPS); EXPECT_NEAR(Z_DISTANCE, refracted.getOrigin()[2], EPS); } }
void randomiseCoordinates(int coordinates[]) { int originX = getOrigin(WIDTH), originY = getOrigin(HEIGHT), i; for (i = 0; coordinates[i] != ENDOFCOORDINATES; i++) { if (i%2) { coordinates[i] += originX; } else { coordinates[i] += originY; } } }
void SPlaneSlicer::applySliceTranslation(vtkSmartPointer<vtkMatrix4x4> vtkMat) const { auto image = this->getInput< ::fwData::Image >(s_EXTENT_IN); ::fwData::Object::sptr index; switch (m_orientation) { case ::fwDataTools::helper::MedicalImageAdaptor::Orientation::X_AXIS: index = image->getField(::fwDataTools::fieldHelper::Image::m_sagittalSliceIndexId); break; case ::fwDataTools::helper::MedicalImageAdaptor::Orientation::Y_AXIS: index = image->getField(::fwDataTools::fieldHelper::Image::m_frontalSliceIndexId); break; case ::fwDataTools::helper::MedicalImageAdaptor::Orientation::Z_AXIS: index = image->getField(::fwDataTools::fieldHelper::Image::m_axialSliceIndexId); break; } const int idx = ::fwData::Integer::dynamicCast(index)->value(); const auto& spacing = image->getSpacing(); const auto& origin = image->getOrigin(); const std::uint8_t axis = static_cast<std::uint8_t>(m_orientation); const double trans = spacing[axis] * static_cast<double>(idx) + origin[axis]; vtkSmartPointer<vtkMatrix4x4> transMat = vtkSmartPointer<vtkMatrix4x4>::New(); transMat->Identity(); transMat->SetElement(axis, 3, trans); vtkMatrix4x4::Multiply4x4(vtkMat, transMat, vtkMat); }
void CCPrimitiveObj::moveVerticesToOrigin() { if( movedToOrigin == false ) { const CCVector3 origin = getOrigin(); mmX.reset(); mmY.reset(); mmZ.reset(); for( uint i=0; i<vertexCount; ++i ) { const uint index = i*3; float &x = vertices[index+0]; float &y = vertices[index+1]; float &z = vertices[index+2]; x -= origin.x; y -= origin.y; z -= origin.z; mmX.consider( x ); mmY.consider( y ); mmZ.consider( z ); } movedToOrigin = true; } }
void RBlock::print(QDebug dbg) const { dbg.nospace() << "RBlock("; RObject::print(dbg); dbg.nospace() << ", name: " << getName() << ", origin: " << getOrigin() << ")"; }
sf::FloatRect Animation::getLocalBounds() const { return sf::FloatRect( getOrigin(), static_cast<sf::Vector2f>( GetFrameSize() ) ); }
bool OccupancyGrid::writeOccupancyGridToBagFile(std::string bag_filename, std::string topic_name) { arm_navigation_msgs::CollisionMap map; arm_navigation_msgs::OrientedBoundingBox box; std::vector<double> dim(3,0), origin(3,0); getOrigin(origin[0], origin[1], origin[2]); getWorldSize(dim[0], dim[1], dim[2]); map.header.frame_id = reference_frame_; box.angle = 0.0; box.extents.x = grid_->getResolution(); box.extents.y = grid_->getResolution(); box.extents.z = grid_->getResolution(); for(double x=origin[0]; x<=origin[0]+dim[0]; x+=grid_->getResolution()) { for(double y=origin[1]; y<=origin[1]+dim[1]; y+=grid_->getResolution()) { for(double z=origin[2]; z<=origin[2]+dim[2]; z+=grid_->getResolution()) { if(getDistanceFromPoint(x,y,z) == 0) { box.center.x = x; box.center.y = y; box.center.z = z; map.boxes.push_back(box); } } } } return writeCollisionMapToBagFile(map, bag_filename, topic_name); }
void CClient :: autoEventWaypoint ( int iType, float fRadius, bool bAtOtherOrigin, int iTeam, Vector vOrigin, bool bIgnoreTeam, bool bAutoType ) { m_iAutoEventWaypoint = iType; m_fAutoEventWaypointRadius = fRadius; CBotMod *pMod = CBotGlobals::getCurrentMod(); m_bAutoEventWaypointAutoType = bAutoType; if ( bAtOtherOrigin ) { m_vAutoEventWaypointOrigin = vOrigin; } else { m_vAutoEventWaypointOrigin = getOrigin(); iTeam = CClassInterface::getTeam(m_pPlayer); } if ( bIgnoreTeam ) m_iAutoEventWaypointTeam = 0; else { pMod->getTeamOnlyWaypointFlags(iTeam,&m_iAutoEventWaypointTeamOn,&m_iAutoEventWaypointTeamOff); m_iAutoEventWaypointTeam = iTeam; } }
TEST_F(LensTest, central_ray_should_pass_through) { Ray central{{0, 0, 0}, DIR_Z}; auto refracted = lens.refract(central); ASSERT_THAT(refracted, RayPassesThrough(FOCAL_POINT, EPS)); ASSERT_THAT(central, RayPassesThrough(refracted.getOrigin(), EPS)); }
Math::CVecR3 WaveguideRectangular::getWeight( const Math::CVecR3& pos) const { // Return normalized weights for electric field components. static const Math::Real pi = acos(-1.0); Math::CVecR3 res; Math::CVecR3 rPos = pos - getOrigin(); const Math::Real m = pi * getMode().first / getWidth(); const Math::Real n = pi * getMode().second / getHeight(); Math::Real normFactor = m; if (n > m) { normFactor = n; } //const Math::Real betaC = sqrt(pow(m,2) + pow(n,2)); if (getExcitationMode() == Waveguide::TE) { res(Math::Constants::x) = n * cos(m * rPos(Math::Constants::x)) * sin(n * rPos(Math::Constants::y)) / normFactor; res(Math::Constants::y) = - m * sin(m * rPos(Math::Constants::x)) * cos(n * rPos(Math::Constants::y)) / normFactor; res(Math::Constants::z) = (Math::Real) 0.0; } else { res(Math::Constants::x) = - m * cos(m * rPos(Math::Constants::x)) * sin(n * rPos(Math::Constants::y)) / normFactor; res(Math::Constants::y) = - m * sin(m * rPos(Math::Constants::x)) * cos(n * rPos(Math::Constants::y)) / normFactor; res(Math::Constants::z) = (Math::Real) 0.0; } return res; }
void SPlaneSlicer::updating() { this->setReslicerExtent(); this->setReslicerAxes(); auto image = this->getInput< ::fwData::Image >(s_IMAGE_IN); vtkSmartPointer<vtkImageData> vtkimg = vtkSmartPointer<vtkImageData>::New(); ::fwVtkIO::toVTKImage(image, vtkimg.Get()); m_reslicer->SetInputData(vtkimg); m_reslicer->Update(); auto slice = this->getInOut< ::fwData::Image >(s_SLICE_OUT); ::fwVtkIO::fromVTKImage(m_reslicer->GetOutput(), slice); // HACK: Make output slice three-dimensional. // We need to do so in order to visualize it with ::visuVTKAdaptor::SImageSlice. // This is because the adaptor uses a vtkImageActor which doesn't handle 2d images. auto size = slice->getSize(); slice->setSize({{size[0], size[1], 1}}); auto spacing = slice->getSpacing(); slice->setSpacing({{spacing[0], spacing[1], 0 }}); auto origin = slice->getOrigin(); slice->setOrigin({{origin[0], origin[1], 0}}); auto sig = slice->signal< ::fwData::Image::ModifiedSignalType >(::fwData::Image::s_MODIFIED_SIG); sig->asyncEmit(); }
std::ostream& CodeLocation::printTo(std::ostream& out) const { // start with the address ... if (address.isValid()) { out << address; } else { out << "<unknown>"; } // ... followed by the annotation path ... if (!annotationPath.empty()) { out << " / " << join(" / ", annotationPath, [](std::ostream& out, const std::pair<insieme::utils::AnnotationKeyPtr, insieme::core::NodeAddress>& cur) { out << *cur.first << ":" << cur.second; }); } // ... and finish with a source location if present auto origin = getOrigin(); if (origin.isValid()) { if (auto loc = annotations::getLocation(origin)) { out << " - " << *loc; } } return out; }
TEST_F(LensTest, rays_passing_though_the_focal_point_should_become_parallel) { Point destinationPoints[]{ {1, 2, Z_DISTANCE}, {-3, 4, Z_DISTANCE}, {4, 1, Z_DISTANCE}}; for (auto& to : destinationPoints) { auto ray = rayFromTo(FOCAL_POINT, to); auto refracted = lens.refract(ray); EXPECT_THAT(refracted, RayHasDirection(-DIR_Z, EPS)); EXPECT_NEAR(to[0], refracted.getOrigin()[0], EPS); EXPECT_NEAR(to[1], refracted.getOrigin()[1], EPS); EXPECT_NEAR(to[2], refracted.getOrigin()[2], EPS); } }
void EnemyLog::update(float deltaTime , Background *bg) { _aliveTimer += deltaTime; if(!_destroying && _aliveTimer > 5) { //_alive = false; _index = 0; _destroying = true; _animTimer.restart(); move(-31, -31); } if(_spawning){ updateSprite(true); return; } if(_destroying){ updateSprite(false); return; } setTexture(*_texture, true); if(getOrigin().x == 0){ setPosition(getPosition().x + getLocalBounds().width/2+32, getPosition().y + getLocalBounds().height/2+32); setOrigin( getLocalBounds().width/2, getLocalBounds().height/2); } movement(deltaTime, bg); }
// Will be called from subclasses, as is virtual function //---------------------------------------------------------------------------------------------------------------------- void Muscle::toXml(ci::XmlTree& muscle) { // XMLTree muscle provided by subclass //ci::XmlTree muscle("Muscle", ""); muscle.setAttribute("Name", getName()); muscle.setAttribute("IsFlexor", isFlexor()); muscle.setAttribute("IsMono", isMonoArticulate()); ci::XmlTree attach("Attachment",""); attach.setAttribute("Origin", getOrigin()); attach.setAttribute("Insertion", getInsertion()); muscle.push_back(attach); double Fmax = getForceMax(); ci::XmlTree maxForce("MaxIsoForce", toString(Fmax)); muscle.push_back(maxForce); double Vmax = getVelocityMax(); ci::XmlTree maxVel("MaxVelocity", toString(Vmax)); muscle.push_back(maxVel); ci::XmlTree length("Length",""); length.setAttribute("Optimal", getOptimalLength()); length.setAttribute("Min", m_lengthMin); length.setAttribute("Max", m_lengthMax); muscle.push_back(length); ci::XmlTree hillParams("HillParameters",""); hillParams.setAttribute("Shortening", m_hillSh); hillParams.setAttribute("Lengthening", m_hillLn); hillParams.setAttribute("Asymptote", m_hillMax); hillParams.setAttribute("Slope", m_hillSlope); muscle.push_back(hillParams); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void TestFilter::writeFilterParameters(AbstractFilterParametersWriter* writer) { /* Place code that will write the inputs values into a file. reference the AbstractFilterParametersWriter class for the proper API to use. */ writer->writeValue("StlFilePrefix", getStlFilePrefix() ); writer->writeValue("MaxIterations", getMaxIterations() ); writer->writeValue("MisorientationTolerance", getMisorientationTolerance() ); writer->writeValue("InputFile", getInputFile() ); writer->writeValue("InputPath", getInputPath() ); writer->writeValue("OutputFile", getOutputFile() ); writer->writeValue("OutputPath", getOutputPath() ); writer->writeValue("WriteAlignmentShifts", getWriteAlignmentShifts() ); writer->writeValue("ConversionType", getConversionType() ); writer->writeValue("SelectedCellArrayName", getSelectedCellArrayName() ); writer->writeValue("SelectedFieldArrayName", getSelectedFieldArrayName() ); writer->writeValue("SelectedEnsembleArrayName", getSelectedEnsembleArrayName() ); writer->writeValue("SurfaceMeshPointArrayName", getSurfaceMeshPointArrayName() ); writer->writeValue("SurfaceMeshFaceArrayName", getSurfaceMeshFaceArrayName() ); writer->writeValue("SurfaceMeshEdgeArrayName", getSurfaceMeshEdgeArrayName() ); writer->writeValue("SolidMeshPointArrayName", getSolidMeshPointArrayName() ); writer->writeValue("SolidMeshFaceArrayName", getSolidMeshFaceArrayName() ); writer->writeValue("SolidMeshEdgeArrayName", getSolidMeshEdgeArrayName() ); writer->writeValue("Dimensions", getDimensions() ); writer->writeValue("Origin", getOrigin() ); writer->writeValue("CellComparisonInputs", m_CellComparisonInputs); writer->writeValue("AxisAngleRotations", m_AxisAngleRotations); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GenericExample::readFilterParameters(AbstractFilterParametersReader* reader, int index) { /* FILTER_WIDGETCODEGEN_AUTO_GENERATED_CODE BEGIN*/ reader->openFilterGroup(this, index); setStlFilePrefix( reader->readValue("StlFilePrefix", getStlFilePrefix()) ); setMaxIterations( reader->readValue("MaxIterations", getMaxIterations()) ); setMisorientationTolerance( reader->readValue("MisorientationTolerance", getMisorientationTolerance()) ); setInputFile( reader->readValue("InputFile", getInputFile()) ); setInputPath( reader->readValue("InputPath", getInputPath()) ); setOutputFile( reader->readValue("OutputFile", getOutputFile()) ); setOutputPath( reader->readValue("OutputPath", getOutputPath()) ); setWriteAlignmentShifts( reader->readValue("WriteAlignmentShifts", getWriteAlignmentShifts()) ); setConversionType( reader->readValue("ConversionType", getConversionType()) ); setDimensions( reader->readValue("Dimensions", getDimensions()) ); setOrigin( reader->readValue("Origin", getOrigin()) ); setCrystalSymmetryRotations( reader->readValue("CrystalSymmetryRotations", getCrystalSymmetryRotations()) ); setSelectedVoxelCellArrayName( reader->readValue("SelectedVoxelCellArrayName", getSelectedVoxelCellArrayName()) ); setSelectedVoxelFieldArrayName( reader->readValue("SelectedVoxelFieldArrayName", getSelectedVoxelFieldArrayName()) ); setSelectedVoxelEnsembleArrayName( reader->readValue("SelectedVoxelEnsembleArrayName", getSelectedVoxelEnsembleArrayName()) ); setSelectedSurfaceMeshPointArrayName( reader->readValue("SelectedSurfaceMeshPointArrayName", getSelectedSurfaceMeshPointArrayName()) ); setSelectedSurfaceMeshFaceArrayName( reader->readValue("SelectedSurfaceMeshFaceArrayName", getSelectedSurfaceMeshFaceArrayName()) ); setSelectedSurfaceMeshEdgeArrayName( reader->readValue("SelectedSurfaceMeshEdgeArrayName", getSelectedSurfaceMeshEdgeArrayName()) ); setSelectedSolidMeshPointArrayName( reader->readValue("SelectedSolidMeshPointArrayName", getSelectedSolidMeshPointArrayName()) ); setSelectedSolidMeshFaceArrayName( reader->readValue("SelectedSolidMeshFaceArrayName", getSelectedSolidMeshFaceArrayName()) ); setSelectedSolidMeshEdgeArrayName( reader->readValue("SelectedSolidMeshEdgeArrayName", getSelectedSolidMeshEdgeArrayName()) ); setStrVector( reader->readValue("StrVector", getStrVector() ) ); reader->closeFilterGroup(); }
visualization_msgs::MarkerArray OccupancyGrid::getVisualization(std::string type) { visualization_msgs::MarkerArray ma; if(type.compare("bounds") == 0) { double dimx, dimy, dimz, originx, originy, originz; std::vector<geometry_msgs::Point> pts(10); getOrigin(originx, originy, originz); getWorldSize(dimx,dimy,dimz); pts[0].x = originx; pts[0].y = originy; pts[0].z = originz; pts[1].x = originx+dimx; pts[1].y = originy; pts[1].z = originz; pts[2].x = originx+dimx; pts[2].y = originy+dimy; pts[2].z = originz; pts[3].x = originx; pts[3].y = originy+dimy; pts[3].z = originz; pts[4].x = originx; pts[4].y = originy; pts[4].z = originz; pts[5].x = originx; pts[5].y = originy; pts[5].z = originz+dimz; pts[6].x = originx+dimx; pts[6].y = originy; pts[6].z = originz+dimz; pts[7].x = originx+dimx; pts[7].y = originy+dimy; pts[7].z = originz+dimz; pts[8].x = originx; pts[8].y = originy+dimy; pts[8].z = originz+dimz; pts[9].x = originx; pts[9].y = originy; pts[9].z = originz+dimz; ma.markers.resize(1); ma.markers[0] = viz::getLineMarker(pts, 0.05, 10, getReferenceFrame(), "collision_space_bounds", 0); } else if(type.compare("distance_field") == 0) { visualization_msgs::Marker m; // grid_->getIsoSurfaceMarkers(0.01, 0.03, getReferenceFrame(), ros::Time::now(), Eigen::Affine3d::Identity(), m); //grid_->getIsoSurfaceMarkers(0.01, 0.08, getReferenceFrame(), ros::Time::now(), tf::Transform(tf::createIdentityQuaternion(), tf::Vector3(0,0,0)), m); grid_->getIsoSurfaceMarkers(0.01, 0.02, getReferenceFrame(), ros::Time::now(), m); m.color.a +=0.2; ma.markers.push_back(m); } else if(type.compare("occupied_voxels") == 0) { visualization_msgs::Marker marker; std::vector<geometry_msgs::Point> voxels; getOccupiedVoxels(voxels); marker.header.seq = 0; marker.header.stamp = ros::Time::now(); marker.header.frame_id = getReferenceFrame(); marker.ns = "occupied_voxels"; marker.id = 1; marker.type = visualization_msgs::Marker::POINTS; marker.action = visualization_msgs::Marker::ADD; marker.lifetime = ros::Duration(0.0); marker.scale.x = grid_->getResolution() / 2.0; marker.scale.y = grid_->getResolution() / 2.0; marker.scale.z = grid_->getResolution() / 2.0; marker.color.r = 0.8; marker.color.g = 0.3; marker.color.b = 0.5; marker.color.a = 1; marker.points = voxels; ma.markers.push_back(marker); } else ROS_ERROR("No visualization found of type '%s'.", type.c_str()); return ma; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int GenericExample::writeFilterParameters(AbstractFilterParametersWriter* writer, int index) { writer->openFilterGroup(this, index); /* Place code that will write the inputs values into a file. reference the AbstractFilterParametersWriter class for the proper API to use. */ writer->writeValue("StlFilePrefix", getStlFilePrefix()); writer->writeValue("MaxIterations", getMaxIterations()); writer->writeValue("MisorientationTolerance", getMisorientationTolerance()); writer->writeValue("InputFile", getInputFile()); writer->writeValue("InputPath", getInputPath()); writer->writeValue("OutputFile", getOutputFile()); writer->writeValue("OutputPath", getOutputPath()); writer->writeValue("WriteAlignmentShifts", getWriteAlignmentShifts()); writer->writeValue("ConversionType", getConversionType()); writer->writeValue("Dimensions", getDimensions()); writer->writeValue("Origin", getOrigin()); writer->writeValue("CrystalSymmetryRotations", getCrystalSymmetryRotations()); writer->writeValue("SelectedVoxelCellArrayName", getSelectedVoxelCellArrayName()); writer->writeValue("SelectedVoxelFieldArrayName", getSelectedVoxelFieldArrayName()); writer->writeValue("SelectedVoxelEnsembleArrayName", getSelectedVoxelEnsembleArrayName()); writer->writeValue("SelectedSurfaceMeshPointArrayName", getSelectedSurfaceMeshPointArrayName()); writer->writeValue("SelectedSurfaceMeshFaceArrayName", getSelectedSurfaceMeshFaceArrayName()); writer->writeValue("SelectedSurfaceMeshEdgeArrayName", getSelectedSurfaceMeshEdgeArrayName()); writer->writeValue("SelectedSolidMeshPointArrayName", getSelectedSolidMeshPointArrayName()); writer->writeValue("SelectedSolidMeshFaceArrayName", getSelectedSolidMeshFaceArrayName()); writer->writeValue("SelectedSolidMeshEdgeArrayName", getSelectedSolidMeshEdgeArrayName()); writer->writeValue("StrVector", getStrVector()); writer->closeFilterGroup(); return ++index; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void DxReader::writeFilterParameters(AbstractFilterParametersWriter* writer) { writer->writeValue("InputFile", getInputFile() ); writer->writeValue("Origin", getOrigin() ); writer->writeValue("Resolution", getResolution() ); }
void BitmapText::draw(Vectorf parentPos, float parentRot, Vectorf parentOri, Camera const& cam) { Vectorf pos = getPos(); float rot = getRotation(); Vectorf ori = getOrigin(); if (isRelativeToParent()) { pos += parentPos; rot += parentRot; ori += parentOri; } for (std::size_t stringIndex = 0; text_[stringIndex] != '\0'; ++stringIndex) { auto clipIndex = static_cast<unsigned int>(text_[stringIndex] - asciiOffset_); clip_.x = (clipIndex % rowWidth_) * glyphDims_.x; clip_.y = (clipIndex / rowWidth_) * glyphDims_.y; const float rads = 3.14159265 * rot / 180.f; const float distance = stringIndex * glyphDims_.x; Vectorf displacement; displacement.x = distance * std::cos(rads); displacement.y = distance * std::sin(rads); font_.setClip(clip_); font_.setPos(displacement); font_.draw(pos, rot, ori, cam); } }