void maximizeArea(const MarkerPoint* nPoints, int nNumPoints, int nIdx0, int nIdx1, int nIdx2, int& nIdxMax) { int maxArea = 0; for (int i = 0; i < nIdx0; i++) { int area = calcArea(nPoints[i], nPoints[nIdx0], nPoints[nIdx1], nPoints[nIdx2]); if (area > maxArea) { maxArea = area; nIdxMax = i; } } for (int i = nIdx0 + 1; i < nIdx1; i++) { int area = calcArea(nPoints[nIdx0], nPoints[i], nPoints[nIdx1], nPoints[nIdx2]); if (area > maxArea) { maxArea = area; nIdxMax = i; } } for (int i = nIdx1 + 1; i < nIdx2; i++) { int area = calcArea(nPoints[nIdx0], nPoints[nIdx1], nPoints[i], nPoints[nIdx2]); if (area > maxArea) { maxArea = area; nIdxMax = i; } } for (int i = nIdx2 + 1; i < nNumPoints; i++) { int area = calcArea(nPoints[nIdx0], nPoints[nIdx1], nPoints[nIdx2], nPoints[i]); if (area > maxArea) { maxArea = area; nIdxMax = i; } } }
Vector Triangle::getNormalVector(const Point& intersectPoint, const Vector& viewVector) const { if (_normalSet == false) { double cosA = viewVector * _normal; cosA = cosA / (viewVector.getNorm()); if (cosA <= 0) return (_normal * -1); return (_normal); (void)intersectPoint; } else { double aT = calcArea(_absolutePosition, _vertex1, _vertex2), aB = calcArea(intersectPoint, _absolutePosition, _vertex1), aC = calcArea(intersectPoint, _vertex2, _vertex1), aA = aT - aB - aC; double c1 = aA / aT, c2 = aB / aT, c3 = aC / aT; Vector normal = _normal0 * c3 + _normal1 * c1 + _normal2 * c2; normal.normalize(); return (normal); } }
bool OverlapTester::isPointInTriangle(Vector2D &p, Triangle &tr) { float pX = p.getX(); float pY = p.getY(); float p0X = tr.getPointA().getX(); float p0Y = tr.getPointA().getY(); float p1X = tr.getPointB().getX(); float p1Y = tr.getPointB().getY(); float p2X = tr.getPointC().getX(); float p2Y = tr.getPointC().getY(); /* Calculate area of triangle ABC */ float a = calcArea(p0X, p0Y, p1X, p1Y, p2X, p2Y); /* Calculate area of triangle PBC */ float a1 = calcArea (pX, pY, p1X, p1Y, p2X, p2Y); /* Calculate area of triangle PAC */ float a2 = calcArea (p0X, p0Y, pX, pY, p2X, p2Y); /* Calculate area of triangle PAB */ float a3 = calcArea (p0X, p0Y, p1X, p1Y, pX, pY); float aSum = a1 + a2 + a3; /* Check if sum of A1, A2 and A3 is same as A */ return a < (aSum + 0.1f) && a > (aSum - 0.1f); }
int main(int argc, char** argv) { printf("|%10s|%10s|%10s|%10s|\n", "a", "b", "h", "Area"); printf("%10.2f|\n", calcArea(5, 7, 12)); printf("%10.2f|\n", calcArea(2, 1, 33)); printf("%10.2f|\n", calcArea(8.5, 4.3, 2.7)); printf("%10.2f|\n", calcArea(100, 200, 300)); printf("%10.2f|\n", calcArea(0.222, 0.333, 0.555)); return (EXIT_SUCCESS); }
bool calcWeights(const SbVec3f& v1, const SbVec3f& v2, const SbVec3f& v3, const SbVec3f& p, float& w0, float& w1, float& w2) { float fAreaABC = calcArea(v1,v2,v3); float fAreaPBC = calcArea(p,v2,v3); float fAreaPCA = calcArea(p,v3,v1); float fAreaPAB = calcArea(p,v1,v2); w0=fAreaPBC/fAreaABC; w1=fAreaPCA/fAreaABC; w2=fAreaPAB/fAreaABC; return fabs(w0+w1+w2-1.0f)<0.001f; }
void RDirNode::calcRadius() { calcArea(); // was gGourceMinDirSize this->dir_radius = std::max(1.0f, (float)sqrt(dir_area)) * gGourceDirPadding; this->dir_radius_sqrt = sqrt(dir_radius); }
void Triangle::getMappedCoords(const Point& intersectPoint, double& x, double &y) const { double areaA = calcArea(_absolutePosition, _vertex1, intersectPoint); double areaB = calcArea(_vertex1, _vertex2, intersectPoint); double areaC = calcArea(_vertex2, _absolutePosition, intersectPoint); double sum = areaA + areaB + areaC; double b = areaC / sum; double c = areaA / sum; double a = areaB / sum; Point texturePoint = _textureVertex1 + (b * _textureV1 + c * _textureV2) / (a + b + c); x = texturePoint._x; y = -texturePoint._y; }
//Fill out the m_i array with the inverse of the node masses void calcMasses(myGlobals &g) { int i; double *m_i=g.m_i; //Zero out node masses for (i=0;i<g.nnodes;i++) m_i[i]=0.0; //Add mass from surrounding triangles: for (i=0;i<g.nelems;i++) { if(g.validElem[i]){ int n1=g.conn[3*i+0]; int n2=g.conn[3*i+1]; int n3=g.conn[3*i+2]; double area=calcArea(g,i); // if (1 || i%100==0) CkPrintf("Triangle %d (%d %d %d) has area %.3g\n",i,n1,n2,n3,area); double mass=0.333*density*(thickness*area); m_i[n1]+=mass; m_i[n2]+=mass; m_i[n3]+=mass; } } //Include mass from other processors FEM_Update_field(g.m_i_fid,m_i); //Invert masses to get m_i for (i=0;i<g.nnodes;i++) { double mass=m_i[i]; if (mass<1.0e-10) m_i[i]=1.0; //Disconnected node (!) else m_i[i]=1.0/mass; } }
// Hit test triangle bool Triangle::contains( const Vec2f & position ) const { // Get area values using input position and two points from triangle float area0 = calcArea( mDestination, mApex, position ); float area1 = calcArea( mApex, mOrigin, position ); float area2 = calcArea( mOrigin, mDestination, position ); // Sum the absolute values of each area float areaSum = math<float>::abs( area0 ) + math<float>::abs( area1 ) + math<float>::abs( area2 ); // If sum of the three areas is the same as the triangle's // area, the point is inside return areaSum == mArea; }
// Name: Hexagon() // Author: Erick Narvaez // Summary: Contructor for the Hexagon class. Sets the value of the following properties for the // object: sideLength, area, slice area, and size enums. // Arguments: // 1) double length (input). The side length of the hexagon object. Hexagon::Hexagon(double length) { sideLength = length; whole = MEDIUM; slice = MEDIUM; calcArea(); calcSliceArea(); }
int Solution::maximalRectangle(vector<vector<int> > &A) { // Do not write main() function. // Do not read input, instead use the arguments to the function. // Do not print the output, instead return values as specified // Still have a doubt. Checkout www.interviewbit.com/pages/sample_codes/ for more details int row = A.size(); int col = A[0].size(); //vector<vector<int> > dp(row, vector<int>(col, 0)); int dp[row][col]; for(int i=0; i<row; i++){ for(int j=0; j<col; ++j){ if(A[i][j]==1){ if(i==0) dp[i][j] = 1; else dp[i][j] = 1 + dp[i-1][j]; } else{ dp[i][j] = 0; } } } int ans = 0; for(int i = 0; i<row; ++i){ ans = max(ans, calcArea(dp[i], col)); //cout<<i<<" "<<ans<<endl; } return ans; }
void CompressionChamber::calcInicProp(Mechanism mech, double sucChambPress, double sucChambRho, double sucChambExpTemp) { calcArea(); if(mech.getMech() == "crank_rod") { calcDispVol(2*mech.getEccent()); } else if(mech.getMech() == "sinusoidal") { calcDispVol(mech.getStroke()); } calcVol(mech.getSupDeadPt(), mech.getPos()); refrig.setTemp(sucChambExpTemp); refrig.setPress(sucChambPress); refrig.calcRho(); refrig.setRho(sucChambRho); refrig.calcMass(vol); calcPistDiam(); calcContactLength(); }
//O(n*log(n)) void solveProblem(int n) { if (n < 3) return;//we can't construct a convex hull with less than 3 vertices std::sort(vertices+1, vertices+n, comparerCCW);//sort vertices in CCW in relation to vertices[0](lowest vertex) std::stack<Vertex> S; S.push(vertices[0]); S.push(vertices[1]); Vertex stackTop; for (int i = 2; i < n; i++) { stackTop = S.top(); S.pop(); while (crossProduct(S.top(), stackTop, vertices[i]) < 0) { stackTop = S.top(); S.pop(); } S.push(stackTop); //insert again the element that didn't passed the test S.push(vertices[i]); } //From this moment on the convex hull is in the stack... //Now we mark the id's that are present in convex hull char marked[N]; memset(marked, 0, n * sizeof(char)); while (!S.empty()) { marked[S.top().id] = 1; S.pop(); } //Now it's time to calculate areas of poligons inside convex hull int firstVertex; //index of first vertex of polygon INSIDE conevex hull bool startPol = false; //make true starting a new polygon double area; int polysDetected = 0; for (int i = 0; i < n; i++) { if (marked[i] == 0) { if (!startPol) { startPol = true; firstVertex = i-1; //id of first vertex INSIDE convex hull } } else { if (startPol) { startPol = false; //close the polygon //calc area of polygon area = calcArea(firstVertex, i); printf("%d %.1f\n", polysDetected++, area); } } } if (startPol) { //in this case the polygon isn't closed //calc area of polygon area = calcArea2(firstVertex, n); //this is a variation of calcArea printf("%d %.1f\n", polysDetected, area); } }
int main(int argc, char * argv[]) { printf("\nCalculo de la Integral"); printf("\nMetodo de los Trapecios"); printf("\nIntervalo [a, b]"); printf("\nNumero de Trapecios 'n' "); //int n; int a, b; double deltX; printf("\n\nIngresar el valor de a: "); scanf("%d", &a); printf("\nIngresar el valor de b: "); scanf("%d", &b); //printf("\nIngresar el valor de n: "); //scanf("%f", &n); //deltX = (b - a) / n; //Areas double A1 = f(a) + f(b); double AT; double A2; printf("\n n Valorp Valorm Error Relativo"); deltX = (double)(b - a) / 50.0000; A2 = calcArea(50, a, deltX); AT = (deltX / 2) * (A1 + A2); printf("\n 50 %f 184.2016 %f ", AT, error(AT)); deltX = (double)(b - a) / 100.0000; A2 = calcArea(100, a, deltX); AT = (deltX / 2) * (A1 + A2); printf("\n 1000 %f 184.2016 %f ", AT, error(AT)); deltX = (double)(b - a) / 5000.0000; A2 = calcArea(5000, a, deltX); AT = (deltX / 2) * (A1 + A2); printf("\n 5000 %f 184.2016 %f ", AT, error(AT)); printf("\n"); return 0; }//main
float FostroDescriptor::calcPerimeter(FostroImage* image){ FostroErosionFilter erosionFilter(3,3); FostroImage* tmpImage = erosionFilter.applyFilter(image, GRAY); tmpImage->setFilePath("erosionPerim.png"); tmpImage->saveImage(); float erodedArea = calcArea(tmpImage); return (area - erodedArea); }
// Check the quality of triangle i void checkTriangle(myGlobals &g, int i) { double area=calcArea(g,i); if (area<0) { CkError("Triangle %d of chunk %d is inverted! (area=%g)\n", i,FEM_My_partition(),area); CkAbort("Inverted triangle"); } if (area<1.0e-15) { CkError("Triangle %d of chunk %d is a sliver!\n",i,FEM_My_partition()); CkAbort("Sliver triangle"); } }
static double calcMaxArea( GENERAL_COLLECTOR& aCollector, KICAD_T aType ) { double best = 0.0; for( int i = 0; i < aCollector.GetCount(); i++ ) { BOARD_ITEM* item = aCollector[i]; if( item->Type() == aType ) best = std::max(best, calcArea( item ) ); } return best; }
void Polygon::calcCentre() { if ( !area && n_coords ) calcArea(); double float_x = 0.0L, float_y = 0.0L; for ( int i = 0, j = n_coords-1; i < n_coords; j = i++ ) { float_x += ((coords[i].Y()-coords[j].Y())*((coords[i].X()*2)+(coords[i].X()*coords[j].X())+(coords[j].X()*2))); float_y += ((coords[j].X()-coords[i].X())*((coords[i].Y()*2)+(coords[i].Y()*coords[j].Y())+(coords[j].Y()*2))); } float_x /= (6*area); float_y /= (6*area); //printf( "%.2f,%.2f\n", float_x, float_y ); centre = Coord( (int)round(float_x), (int)round(float_y) ); }
static double calcMinArea( GENERAL_COLLECTOR& aCollector, KICAD_T aType ) { double best = std::numeric_limits<double>::max(); if( !aCollector.GetCount() ) return 0.0; for( int i = 0; i < aCollector.GetCount(); i++ ) { BOARD_ITEM* item = aCollector[i]; if( item->Type() == aType ) best = std::min( best, calcArea( item ) ); } return best; }
int main(void) { int seed, n; Triangle tri[100]; printf("乱数 seed : "); scanf("%d", &seed); srand(seed); printf("3角形の個数 : "); scanf("%d", &n); getTriangle(n, tri); calcArea(n, tri); sortTriangle(n, tri); prtTriangle(n, tri); return 0; }
int main() { double ans = 0; int n; printf("Enter number of vertices \n"); scanf("%d", &n); point points[n]; for (int i = 0; i < n; i++) { scanf("%lf %lf", &points[i].x, &points[i].y); } for (int i = 2; i < n; i++) { ans += calcArea(points[0], points[i - 1], points[i]); } printf("\n Answer is: %lf\n", ans); }
Polygon::Polygon( int p_n_coords, const Coord *p_coords ) : n_coords( p_n_coords ) { coords = new Coord[n_coords]; int min_x = -1; int max_x = -1; int min_y = -1; int max_y = -1; for( int i = 0; i < n_coords; i++ ) { coords[i] = p_coords[i]; if ( min_x == -1 || coords[i].X() < min_x ) min_x = coords[i].X(); if ( max_x == -1 || coords[i].X() > max_x ) max_x = coords[i].X(); if ( min_y == -1 || coords[i].Y() < min_y ) min_y = coords[i].Y(); if ( max_y == -1 || coords[i].Y() > max_y ) max_y = coords[i].Y(); } extent = Box( min_x, min_y, max_x, max_y ); calcArea(); calcCentre(); }
void FostroDescriptor::calcDescriptors(FostroImage* image, int c){ area = calcArea(image); perimeter = calcPerimeter(image); calcPerimeter2OverArea(image); calcMomentInvariants(image); }
std::string BaseLoop::decodeMessage(const std::string& data) { std::ostringstream result; std::string cycdata; int index; // prepare data std::string token; std::istringstream stream(data); std::vector<std::string> cmd; while (std::getline(stream, token, ' ') != 0) cmd.push_back(token); if (cmd.size() == 0) return "command missing"; switch (getCase(cmd[0])) { case notfound: result << "command not found"; break; case get: if (cmd.size() < 3 || cmd.size() > 4) { result << "usage: 'get class cmd (sub)'"; break; } index = m_commands->findCommand(data); if (index >= 0) { std::string type = m_commands->getType(index); std::string ebusCommand(A.getParam<const char*>("p_address")); ebusCommand += m_commands->getEbusCommand(index); std::transform(ebusCommand.begin(), ebusCommand.end(), ebusCommand.begin(), tolower); L.log(bas, trace, " type: %s msg: %s", type.c_str(), ebusCommand.c_str()); // send busCommand m_ebusloop->addBusCommand(new BusCommand(type, ebusCommand)); BusCommand* busCommand = m_ebusloop->getBusCommand(); if (busCommand->getResult().c_str()[0] != '-') { // decode data Command* command = new Command(index, (*m_commands)[index], busCommand->getResult()); // return result result << command->calcResult(cmd); delete command; } else { L.log(bas, error, " %s", busCommand->getResult().c_str()); result << busCommand->getResult(); } delete busCommand; } else { result << "ebus command not found"; } break; case set: if (cmd.size() != 4) { result << "usage: 'set class cmd value'"; break; } index = m_commands->findCommand(data.substr(0, data.find(cmd[3])-1)); if (index >= 0) { std::string type = m_commands->getType(index); std::string ebusCommand(A.getParam<const char*>("p_address")); ebusCommand += m_commands->getEbusCommand(index); // encode data Command* command = new Command(index, (*m_commands)[index], cmd[3]); std::string value = command->calcData(); if (value[0] != '-') { ebusCommand += value; } else { L.log(bas, error, " %s", value.c_str()); delete command; break; } std::transform(ebusCommand.begin(), ebusCommand.end(), ebusCommand.begin(), tolower); L.log(bas, event, " type: %s msg: %s", type.c_str(), ebusCommand.c_str()); // send busCommand m_ebusloop->addBusCommand(new BusCommand(type, ebusCommand)); BusCommand* busCommand = m_ebusloop->getBusCommand(); if (busCommand->getResult().c_str()[0] != '-') { // decode result if (busCommand->getResult().substr(busCommand->getResult().length()-8) == "00000000") result << "done"; else result << "error"; } else { L.log(bas, error, " %s", busCommand->getResult().c_str()); result << busCommand->getResult(); } delete busCommand; delete command; } else { result << "ebus command not found"; } break; case cyc: if (cmd.size() < 3 || cmd.size() > 4) { result << "usage: 'cyc class cmd (sub)'"; break; } index = m_commands->findCommand(data); if (index >= 0) { // get cycdata cycdata = m_cycdata->getData(index); if (cycdata != "") { // decode data Command* command = new Command(index, (*m_commands)[index], cycdata); // return result result << command->calcResult(cmd); delete command; } else { result << "no data stored"; } } else { result << "ebus command not found"; } break; case hex: if (cmd.size() != 3) { result << "usage: 'hex type value' (value: ZZPBSBNNDx)"; break; } if ((strcasecmp(cmd[1].c_str(), "MS") == 0) || (strcasecmp(cmd[1].c_str(), "MM") == 0) || (strcasecmp(cmd[1].c_str(), "BC") == 0)) { std::string type = cmd[1]; std::string ebusCommand(A.getParam<const char*>("p_address")); cmd[2].erase(std::remove_if(cmd[2].begin(), cmd[2].end(), isspace), cmd[2].end()); ebusCommand += cmd[2]; std::transform(ebusCommand.begin(), ebusCommand.end(), ebusCommand.begin(), tolower); L.log(bas, trace, " type: %s msg: %s", type.c_str(), ebusCommand.c_str()); // send busCommand m_ebusloop->addBusCommand(new BusCommand(type, ebusCommand)); BusCommand* busCommand = m_ebusloop->getBusCommand(); if (busCommand->getResult().c_str()[0] == '-') L.log(bas, error, " %s", busCommand->getResult().c_str()); result << busCommand->getResult(); delete busCommand; } else { result << "specified message type is incorrect"; } break; case dump: if (cmd.size() != 2) { result << "usage: 'dump state' (state: on|off)"; break; } if (cmd[1] == "on") m_ebusloop->dump(true); if (cmd[1] == "off") m_ebusloop->dump(false); result << "done"; break; case logarea: if (cmd.size() != 2) { result << "usage: 'logarea area,area,..' (area: bas|net|bus|cyc|all)"; break; } L.getSink(0)->setAreas(calcArea(cmd[1])); result << "done"; break; case loglevel: if (cmd.size() != 2) { result << "usage: 'loglevel level' (level: error|event|trace|debug)"; break; } L.getSink(0)->setLevel(calcLevel(cmd[1])); result << "done"; break; case help: result << "commands:" << std::endl << " get - fetch ebus data 'get class cmd (sub)'" << std::endl << " set - set ebus values 'set class cmd value'" << std::endl << " cyc - fetch cycle data 'cyc class cmd (sub)'" << std::endl << " hex - send given hex value 'hex type value' (value: ZZPBSBNNDx)" << std::endl << " dump - change dump state 'dump state' (state: on|off)" << std::endl << " logarea - change log area 'logarea area,area,..' (area: bas|net|bus|cyc|all)" << std::endl << " loglevel - change log level 'loglevel level' (level: error|event|trace|debug)" << std::endl << " quit - close connection" << std::endl << " help - print this page"; break; default: break; } return result.str(); }
extern "C" void driver(void) { int ignored; int i, count; int myChunk=FEM_My_partition(); /*Add a refinement object to FEM array*/ CkPrintf("[%d] begin init\n",myChunk); FEM_REFINE2D_Init(); CkPrintf("[%d] end init\n",myChunk); myGlobals g; FEM_Register(&g,(FEM_PupFn)pup_myGlobals); init_myGlobal(&g); g.nnodes = FEM_Mesh_get_length(FEM_Mesh_default_read(),FEM_NODE); int maxNodes = g.nnodes; g.maxnodes=2*maxNodes; g.m_i_fid=FEM_Create_field(FEM_DOUBLE,1,0,sizeof(double)); resize_nodes((void *)&g,&g.nnodes,&maxNodes); int nghost=0; g.nelems=FEM_Mesh_get_length(FEM_Mesh_default_read(),FEM_ELEM); g.maxelems=g.nelems; resize_elems((void *)&g,&g.nelems,&g.maxelems); FEM_REFINE2D_Newmesh(FEM_Mesh_default_read(),FEM_NODE,FEM_ELEM); //Initialize associated data for (i=0;i<g.maxnodes;i++) { g.R_net[i]=g.d[i]=g.v[i]=g.a[i]=vector2d(0.0); } //Apply a small initial perturbation to positions for (i=0;i<g.nnodes;i++) { const double max=1.0e-15/15.0; //Tiny perturbation g.d[i].x+=max*(i&15); g.d[i].y+=max*((i+5)&15); } int fid=FEM_Create_field(FEM_DOUBLE,2,0,sizeof(vector2d)); for (i=0;i<g.nelems;i++){ checkTriangle(g,i); } sleep(5); //Timeloop if (CkMyPe()==0){ CkPrintf("Entering timeloop\n"); } // int tSteps=0x70FF00FF; int tSteps=4; int z=13; calcMasses(g); double startTime=CkWallTimer(); double curArea=2.5e-5/1024; int t = 0; // THIS IS THE INITIAL MESH SENT TO NetFEM if (1) { //Publish data to the net publishMeshToNetFEM(g,myChunk,t); } double desiredArea; /* //should not be necessary as it would have been set in the init for (i=0; i<g.nnodes; i++) { g.validNode[i] = 1; } for (i=0; i<g.nelems; i++) { g.validElem[i] = 1; }*/ double avgArea = 0.0; for (i=0;i<g.nelems;i++) { avgArea += calcArea(g, i); } avgArea /= g.nelems; for (t=1;t<=tSteps;t++) { /* if (1) { //Structural mechanics //Compute forces on nodes exerted by elements CST_NL(g.coord,g.conn,g.R_net,g.d,matConst,g.nnodes,g.nelems,g.S11,g.S22,g.S12); //Communicate net force on shared nodes FEM_Update_field(fid,g.R_net); //Advance node positions advanceNodes(dt,g.nnodes,g.coord,g.R_net,g.a,g.v,g.d,g.m_i,(t%4)==0); }*/ //Debugging/perf. output double curTime=CkWallTimer(); double total=curTime-startTime; startTime=curTime; vector2d *loc; double *areas; // prepare to coarsen loc=new vector2d[2*g.nnodes]; for (i=0;i<g.nnodes;i++) { loc[i]=g.coord[i];//+g.d[i]; } areas=new double[g.nelems]; for (i=0;i<g.nelems;i++) { areas[i] = avgArea; } //coarsen one element at a time //int coarseIdx = (23 + 4*t)%g.nnodes; //areas[coarseIdx] = calcArea(g,coarseIdx)*2.5; CkPrintf("[%d] Starting coarsening step: %d nodes, %d elements\n", myChunk,countValidEntities(g.validNode,g.nnodes),countValidEntities(g.validElem,g.nelems)); FEM_REFINE2D_Coarsen(FEM_Mesh_default_read(),FEM_NODE,(double *)g.coord,FEM_ELEM,areas,FEM_SPARSE); repeat_after_split((void *)&g); g.nelems = FEM_Mesh_get_length(FEM_Mesh_default_read(),FEM_ELEM); g.nnodes = FEM_Mesh_get_length(FEM_Mesh_default_read(),FEM_NODE); CkPrintf("[%d] Done with coarsening step: %d nodes, %d elements\n", myChunk,countValidEntities(g.validNode,g.nnodes),countValidEntities(g.validElem,g.nelems)); delete [] loc; delete[] areas; // THIS IS THE COARSENED MESH SENT TO NetFEM if (1) { //Publish data to the net publishMeshToNetFEM(g,myChunk,2*t-1); } //prepare to refine loc=new vector2d[2*g.nnodes]; for (i=0;i<g.nnodes;i++) { loc[i]=g.coord[i];//+g.d[i]; } areas=new double[g.nelems]; for (i=0;i<g.nelems;i++) { areas[i] = avgArea; } //refine one element at a time //int refIdx = (13 + 3*t)%g.nnodes; //areas[refIdx] = calcArea(g,refIdx)/1.5; CkPrintf("[%d] Starting refinement step: %d nodes, %d elements\n", myChunk,countValidEntities(g.validNode,g.nnodes),countValidEntities(g.validElem,g.nelems)); FEM_REFINE2D_Split(FEM_Mesh_default_read(),FEM_NODE,(double *)loc,FEM_ELEM,areas,FEM_SPARSE); repeat_after_split((void *)&g); g.nelems = FEM_Mesh_get_length(FEM_Mesh_default_read(),FEM_ELEM); g.nnodes = FEM_Mesh_get_length(FEM_Mesh_default_read(),FEM_NODE); CkPrintf("[%d] Done with refinement step: %d nodes, %d elements\n", myChunk,countValidEntities(g.validNode,g.nnodes),countValidEntities(g.validElem,g.nelems)); delete [] loc; delete[] areas; // THIS IS THE REFINED MESH SENT TO NetFEM if (1) { //Publish data to the net publishMeshToNetFEM(g,myChunk,2*t); } } if (CkMyPe()==0) CkPrintf("Driver finished\n"); }
// Update area void Triangle::calcArea() { mArea = calcArea( mOrigin, mDestination, mApex ); }
// todo: explain the selection heuristics void SELECTION_TOOL::guessSelectionCandidates( GENERAL_COLLECTOR& aCollector ) const { std::set<BOARD_ITEM*> rejected; const double footprintAreaRatio = 0.2; const double modulePadMinCoverRatio = 0.45; const double padViaAreaRatio = 0.5; const double trackViaLengthRatio = 2.0; const double trackTrackLengthRatio = 0.3; const double textToFeatureMinRatio = 0.2; const double textToFootprintMinRatio = 0.4; LAYER_ID actLayer = m_frame->GetActiveLayer(); LSET silkLayers( 2, B_SilkS, F_SilkS ); if( silkLayers[actLayer] ) { std::set<BOARD_ITEM*> preferred; for( int i = 0; i < aCollector.GetCount(); ++i ) { BOARD_ITEM* item = aCollector[i]; if ( item->Type() == PCB_MODULE_TEXT_T || item->Type() == PCB_TEXT_T || item->Type() == PCB_LINE_T ) if ( silkLayers[item->GetLayer()] ) preferred.insert ( item ); } if( preferred.size() != 0 ) { aCollector.Empty(); BOOST_FOREACH( BOARD_ITEM* item, preferred ) aCollector.Append( item ); return; } } if( aCollector.CountType( PCB_MODULE_TEXT_T ) > 0 ) { for( int i = 0; i < aCollector.GetCount(); ++i ) if( TEXTE_MODULE* txt = dyn_cast<TEXTE_MODULE*>( aCollector[i] ) ) { double textArea = calcArea( txt ); for( int j = 0; j < aCollector.GetCount(); ++j ) { BOARD_ITEM* item = aCollector[j]; double areaRatio = calcRatio( textArea, calcArea( item ) ); if( item->Type() == PCB_MODULE_T && areaRatio < textToFootprintMinRatio ) { //printf("rejectModuleN\n"); rejected.insert( item ); } switch( item->Type() ) { case PCB_TRACE_T: case PCB_PAD_T: case PCB_LINE_T: case PCB_VIA_T: case PCB_MODULE_T: if( areaRatio > textToFeatureMinRatio ) { //printf("t after moduleRejected\n"); rejected.insert( txt ); } break; default: break; } } } } if( aCollector.CountType( PCB_MODULE_T ) > 0 ) { double minArea = calcMinArea( aCollector, PCB_MODULE_T ); double maxArea = calcMaxArea( aCollector, PCB_MODULE_T ); if( calcRatio( minArea, maxArea ) <= footprintAreaRatio ) { for( int i = 0; i < aCollector.GetCount(); ++i ) if( MODULE* mod = dyn_cast<MODULE*>( aCollector[i] ) ) { double normalizedArea = calcRatio( calcArea(mod), maxArea ); if( normalizedArea > footprintAreaRatio ) { //printf("rejectModule1\n"); rejected.insert( mod ); } } } } if( aCollector.CountType ( PCB_PAD_T ) > 0 ) { for( int i = 0; i < aCollector.GetCount(); ++i ) { if ( D_PAD* pad = dyn_cast<D_PAD*>( aCollector[i] ) ) { double ratio = pad->GetParent()->PadCoverageRatio(); if( ratio < modulePadMinCoverRatio ) rejected.insert( pad->GetParent() ); } } } if( aCollector.CountType( PCB_VIA_T ) > 0 ) { for( int i = 0; i < aCollector.GetCount(); ++i ) { if( VIA* via = dyn_cast<VIA*>( aCollector[i] ) ) { double viaArea = calcArea( via ); for( int j = 0; j < aCollector.GetCount(); ++j ) { BOARD_ITEM* item = aCollector[j]; double areaRatio = calcRatio ( viaArea, calcArea( item ) ); if( item->Type() == PCB_MODULE_T && areaRatio < modulePadMinCoverRatio ) rejected.insert( item ); if( item->Type() == PCB_PAD_T && areaRatio < padViaAreaRatio ) rejected.insert( item ); if( TRACK* track = dyn_cast<TRACK*>( item ) ) { if( track->GetNetCode() != via->GetNetCode() ) continue; double lenRatio = (double) ( track->GetLength() + track->GetWidth() ) / (double) via->GetWidth(); if( lenRatio > trackViaLengthRatio ) rejected.insert( track ); } } } } } int nTracks = aCollector.CountType ( PCB_TRACE_T ); if( nTracks > 0 ) { double maxLength = 0.0; double minLength = std::numeric_limits<double>::max(); double maxArea = 0.0; for( int i = 0; i < aCollector.GetCount(); ++i ) if ( TRACK *track = dyn_cast<TRACK*> ( aCollector[i] ) ) { maxLength = std::max( track->GetLength(), maxLength ); maxLength = std::max( (double)track->GetWidth(), maxLength ); minLength = std::min( std::max ( track->GetLength(), (double)track->GetWidth() ), minLength ); double area = ( track->GetLength() + track->GetWidth() * track->GetWidth() ); maxArea = std::max(area, maxArea); } if( maxLength > 0.0 && minLength/maxLength < trackTrackLengthRatio && nTracks > 1 ) { for( int i = 0; i < aCollector.GetCount(); ++i ) { if( TRACK* track = dyn_cast<TRACK*>( aCollector[i] ) ) { double ratio = std::max( (double) track->GetWidth(), track->GetLength()) / maxLength; if( ratio > trackTrackLengthRatio ) rejected.insert( track) ; } } } for( int j = 0; j < aCollector.GetCount(); ++j ) { if( MODULE* mod = dyn_cast<MODULE*>( aCollector[j] ) ) { double ratio = maxArea / mod->GetFootprintRect().GetArea(); if( ratio < modulePadMinCoverRatio ) { //printf("rejectModule\n"); rejected.insert( mod ); } } } } BOOST_FOREACH( BOARD_ITEM* item, rejected ) { aCollector.Remove( item ); }
void ImgWarp_MLS_Rigid::calcDelta(){ int i, j, k; Point_< double > swq, qstar, newP, tmpP; double sw; double ratio; if (preScale){ ratio = sqrt(calcArea(newDotL) / calcArea(oldDotL)); for (i=0; i<nPoint; i++) newDotL[i] *= 1/ratio; } double *w=new double[nPoint]; rDx.create(tarH, tarW); rDy.create(tarH, tarW); if (nPoint < 2){ rDx.setTo(0); rDy.setTo(0); return; } Point_< double > swp, pstar, curV, curVJ, Pi, PiJ, Qi; double miu_r; for (i = 0; ; i+=gridSize){ if (i>=tarW && i<tarW+gridSize - 1) i=tarW-1; else if (i>=tarW) break; for (j = 0; ; j+=gridSize){ if (j>=tarH && j<tarH+gridSize - 1) j = tarH - 1; else if (j>=tarH) break; sw = 0; swp.x = swp.y = 0; swq.x = swq.y = 0; newP.x = newP.y = 0; curV.x = i; curV.y = j; for (k = 0; k < nPoint; k++){ if ((i==oldDotL[k].x) && j==oldDotL[k].y) break; if (alpha==1) w[k] = 1/((i-oldDotL[k].x)*(i-oldDotL[k].x)+ (j-oldDotL[k].y)*(j-oldDotL[k].y)); else w[k] = pow((i-oldDotL[k].x)*(i-oldDotL[k].x)+ (j-oldDotL[k].y)*(j-oldDotL[k].y), -alpha); sw = sw + w[k]; swp = swp + w[k] * oldDotL[k]; swq = swq + w[k] * newDotL[k]; } if ( k == nPoint ) { pstar = (1 / sw) * swp ; qstar = 1/sw * swq; // qDebug("pstar: (%f, %f)", pstar[0], pstar[1]); // Calc miu_r //miu_s = 0; double s1=0, s2=0; for (k = 0; k < nPoint; k++){ if (i==oldDotL[k].x && j==oldDotL[k].y) continue; Pi = oldDotL[k] - pstar; PiJ.x = -Pi.y, PiJ.y = Pi.x; Qi = newDotL[k] - qstar; s1 += w[k] * Qi.dot(Pi); s2 += w[k] * Qi.dot(PiJ); } miu_r = sqrt(s1*s1 + s2*s2); curV -= pstar; curVJ.x = -curV.y, curVJ.y = curV.x; for (k = 0; k < nPoint; k++){ if (i==oldDotL[k].x && j==oldDotL[k].y) continue; Pi = oldDotL[k] - pstar; PiJ.x = -Pi.y, PiJ.y = Pi.x; tmpP.x = Pi.dot(curV) * newDotL[k].x - PiJ.dot(curV) * newDotL[k].y; tmpP.y = -Pi.dot(curVJ) * newDotL[k].x + PiJ.dot(curVJ) * newDotL[k].y; tmpP *= w[k]/miu_r; newP += tmpP; } newP += qstar; } else { newP = newDotL[k]; } if (preScale){ rDx(j, i) = newP.x * ratio - i; rDy(j, i) = newP.y * ratio - j; } else { rDx(j, i) = newP.x - i; rDy(j, i) = newP.y - j; } } } delete [] w; if (preScale){ for (i=0; i<nPoint; i++) newDotL[i] *= ratio; } // cout<<rDx<<endl; }