Bezier::Bezier( intf_thread_t *p_intf, const vector<float> &rAbscissas, const vector<float> &rOrdinates, Flag_t flag ) : SkinObject( p_intf ) { // Copy the control points coordinates m_ptx.assign( rAbscissas.begin(), rAbscissas.end() ); m_pty.assign( rOrdinates.begin(), rOrdinates.end() ); // We expect m_ptx and m_pty to have the same size, of course m_nbCtrlPt = m_ptx.size(); // Precalculate the factoriels m_ft.push_back( 1 ); for( int i = 1; i < m_nbCtrlPt; i++ ) { m_ft.push_back( i * m_ft[i - 1] ); } // Calculate the first point int oldx, oldy; computePoint( 0, oldx, oldy ); m_leftVect.push_back( oldx ); m_topVect.push_back( oldy ); m_percVect.push_back( 0 ); // Calculate the other points float percentage; int cx, cy; for( float j = 1; j <= MAX_BEZIER_POINT; j++ ) { percentage = j / MAX_BEZIER_POINT; computePoint( percentage, cx, cy ); if( ( flag == kCoordsBoth && ( cx != oldx || cy != oldy ) ) || ( flag == kCoordsX && cx != oldx ) || ( flag == kCoordsY && cy != oldy ) ) { m_percVect.push_back( percentage ); m_leftVect.push_back( cx ); m_topVect.push_back( cy ); oldx = cx; oldy = cy; } } m_nbPoints = m_leftVect.size(); // If we have only one control point, we duplicate it // This allows to simplify the algorithms used in the class if( m_nbPoints == 1 ) { m_leftVect.push_back( m_leftVect[0] ); m_topVect.push_back( m_topVect[0] ); m_percVect.push_back( 1 ); m_nbPoints = 2; } // Ensure that the percentage of the last point is always 1 m_percVect[m_nbPoints - 1] = 1; }
void computeScreenQuad( const D3DXMATRIX& inverseview, const D3DXMATRIX& view, const D3DXMATRIX& proj, BYTE* verts, BYTE* colors, DWORD stride, const Vector& p0, DWORD col0, float size0, const Vector& p1, DWORD col1, float size1, bool constantsize) { // Compute delta in camera space Vector Delta; transPoint3x3(Delta, p1-p0, view); // Compute size factors float SizeP0 = size0; float SizeP1 = size1; /* if(constantsize) { // Compute scales so that screen-size is constant SizeP0 *= computeConstantScale(p0, view, proj); SizeP1 *= computeConstantScale(p1, view, proj); } */ // Compute quad vertices float Theta0 = atan2f(-Delta.x, -Delta.y); float c0 = SizeP0 * cosf(Theta0); float s0 = SizeP0 * sinf(Theta0); computePoint(*((Vector*)verts), c0, -s0, inverseview, p0); verts+=stride; computePoint(*((Vector*)verts), -c0, s0, inverseview, p0); verts+=stride; float Theta1 = atan2f(Delta.x, Delta.y); float c1 = SizeP1 * cosf(Theta1); float s1 = SizeP1 * sinf(Theta1); computePoint(*((Vector*)verts), -c1, s1, inverseview, p1); verts+=stride; computePoint(*((Vector*)verts), c1, -s1, inverseview, p1); verts+=stride; /* // Output uvs if needed if(uvs) { *((float*)uvs) = 0.0f; *((float*)(uvs+4)) = 1.0f; uvs+=stride; *((float*)uvs) = 0.0f; *((float*)(uvs+4)) = 0.0f; uvs+=stride; *((float*)uvs) = 1.0f; *((float*)(uvs+4)) = 1.0f; uvs+=stride; *((float*)uvs) = 1.0f; *((float*)(uvs+4)) = 0.0f; uvs+=stride; } */ // Output color if needed if(colors) { *((DWORD*)colors) = col0; colors+=stride; *((DWORD*)colors) = col0; colors+=stride; *((DWORD*)colors) = col1; colors+=stride; *((DWORD*)colors) = col1; colors+=stride; } }
template <typename PointInT, typename PointNT, typename PointOutT> void pcl::ShapeContext3DEstimation<PointInT, PointNT, PointOutT>::computeFeature (PointCloudOut &output) { assert (descriptor_length_ == 1980); output.is_dense = true; // Iterate over all points and compute the descriptors for (size_t point_index = 0; point_index < indices_->size (); point_index++) { //output[point_index].descriptor.resize (descriptor_length_); // If the point is not finite, set the descriptor to NaN and continue if (!isFinite ((*input_)[(*indices_)[point_index]])) { for (size_t i = 0; i < descriptor_length_; ++i) output[point_index].descriptor[i] = std::numeric_limits<float>::quiet_NaN (); memset (output[point_index].rf, 0, sizeof (output[point_index].rf[0]) * 9); output.is_dense = false; continue; } std::vector<float> descriptor (descriptor_length_); if (!computePoint (point_index, *normals_, output[point_index].rf, descriptor)) output.is_dense = false; for (size_t j = 0; j < descriptor_length_; ++j) output[point_index].descriptor[j] = descriptor[j]; } }
// ----------------------------------------------------------------- // // @details This manages the computation of the pixels for which this // task is responsible. // // ----------------------------------------------------------------- void MandelTask::execute() { // // Compute this only one time for all pixels. auto log2MaxIterations = std::log2(std::log(m_maxIterations)); // // Now that we are about to do some work, reserve the memory we need to store the results. uint16_t rows = (m_endRow - m_startRow) + 1; m_pixels.resize(rows * m_sizeX); // // Premature optimization, I know, but just can't help myself. auto pixels = m_pixels.data(); double currentY = m_startY; for (int row = 0; row < rows; row++, currentY += m_deltaY) { double currentX = m_startX; for (int x = 0; x < m_sizeX; x++, currentX += m_deltaX) { auto iterations = computePoint(currentX, currentY, m_maxIterations); // // Use the smooth coloring algorithm to determine the color index; double colorIndex = iterations - log2MaxIterations; colorIndex = (colorIndex / m_maxIterations) * 768; colorIndex = std::min(colorIndex, 767.0); colorIndex = std::max(colorIndex, 0.0); pixels[row * m_sizeX + x] = static_cast<uint16_t>(colorIndex); } } }
Vect RayTracer::computeDirection(uint x, uint y) { Point_2D p = computePoint(x, y); Vect dx = (horizontal()).linearMult(2 * p.x - 1); Vect dy = (vertical()).linearMult(2 * p.y - 1); Vect dir = imageCenter + dx + dy; // dir.normalize(); TODO: fix tests return dir; }
BSpline::BSpline(int m, int n, int resolution, BSPoint *control) :n_control_points(m), n_degree(n), knots(std::vector<int>(m+n+2, 0)), curve(new CvPoint[resolution]) { double increment, interval; BSPoint tmp_point; int output_index; computeKnots(); increment = (double) (m - n + 1)/(resolution - 1); // why ? interval = 0; for (output_index = 0; output_index < resolution - 1; ++output_index){ computePoint(control, &tmp_point, interval); curve[output_index].x = round(tmp_point.x); curve[output_index].y = round(tmp_point.y); interval += increment; } curve[resolution-1].x=control[m].x; curve[resolution-1].y=control[m].y; }
int main(int argc, char** argv) { // mandelbrot int* pixels; int i, j; int color; // mpi int nproc, iproc; int* mySendArr; int* myRecvArr; MPI_Status status; // miscellaneous int loop; // used as boolean int loopCount; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &nproc); MPI_Comm_rank(MPI_COMM_WORLD, &iproc); // everyone needs a send and a recv array // the extra 1 is for the start location mySendArr = (int*)malloc((BLOCK_WIDTH * BLOCK_HEIGHT + 1) * sizeof(int)); myRecvArr = (int*)malloc((BLOCK_WIDTH * BLOCK_HEIGHT + 1) * sizeof(int)); if (iproc == 0) { // master code int numJobs; int jobCount; int jobStart; double timestart, timefinish, timetaken; numJobs = NUM_JOBS; jobCount = 0; //fprintf(stderr,"(%d) I'm the master\n",iproc); pixels = (int*)malloc(WIDTH * HEIGHT * sizeof(int)); timestart = When(); /* for (j = 0; j < HEIGHT; j++) { for (i = 0; i < WIDTH; i++) { pixels[i + j * WIDTH] = computePoint(i, j); } } */ //loop = 1; for (loopCount = 0; loopCount < (NUM_JOBS * 2 + nproc - 1); loopCount++) { //fprintf(stderr,"(%d) I'm waiting\n",iproc); MPI_Recv(myRecvArr,1,MPI_INT,MPI_ANY_SOURCE,0,MPI_COMM_WORLD,&status); // fprintf(stderr,"(%d) %d sent me a message: %lf\n",iproc,status.MPI_SOURCE,myRecvArr[0]); if (myRecvArr[0] == -1) { // worker wants more work //fprintf(stderr,"(%d) %d wants more work\n",iproc,status.MPI_SOURCE); if (numJobs > 0) { // tell worker there is a job starting at numJobs - 1 * BLOCK_WIDTH mySendArr[0] = jobCount * BLOCK_WIDTH; jobCount++; MPI_Send(mySendArr,1,MPI_INT,status.MPI_SOURCE,0,MPI_COMM_WORLD); numJobs--; } else { // tell worker there isn't any more mySendArr[0] = -1; MPI_Send(mySendArr,1,MPI_INT,status.MPI_SOURCE,0,MPI_COMM_WORLD); } } else if (myRecvArr[0] == -2) { // worker wants to send finished work //fprintf(stderr,"(%d) %d wants to send me their work\n",iproc,status.MPI_SOURCE); MPI_Recv(myRecvArr,BLOCK_WIDTH * BLOCK_HEIGHT + 1,MPI_INT,status.MPI_SOURCE,0,MPI_COMM_WORLD,&status); // worker sent work with start number //fprintf(stderr,"(%d) %d sent me their work starting at %d\n",iproc,status.MPI_SOURCE,myRecvArr[0]); // copy work into pixel array jobStart = myRecvArr[0]; for (i = 1; i < BLOCK_WIDTH * BLOCK_HEIGHT + 1; i++) { pixels[i-1 + jobStart] = myRecvArr[i]; //fprintf(stderr,"%d ",pixels[i-1 + jobStart]); } } //loop = 0; } timefinish = When(); timetaken = timefinish - timestart; //fprintf(stderr,"(%d) I'm finished\n",iproc); fprintf(stdout,"(%d) Time taken: %lf\n",iproc,timetaken); fileWrite(pixels); free(pixels); } else { // worker code int myJobStart; //fprintf(stderr,"\t(%d) I'm a worker\n",iproc); pixels = (int*)malloc(BLOCK_WIDTH * BLOCK_HEIGHT * sizeof(int)); loop = 1; while (loop) { // ask master for work mySendArr[0] = -1; MPI_Send(mySendArr,1,MPI_INT,0,0,MPI_COMM_WORLD); // recv response (starting number or -1) MPI_Recv(myRecvArr,1,MPI_INT,0,0,MPI_COMM_WORLD,&status); if (myRecvArr[0] == -1) { // -1 means no more //fprintf(stderr,"\t(%d) Master says no more work\n",iproc); loop = 0; } else { //fprintf(stderr,"\t(%d) Master gave me start of %d\n",iproc,myRecvArr[0]); myJobStart = myRecvArr[0]; // do work #pragma omp parallel for private(i, j) for (j = 0; j < BLOCK_HEIGHT; j++) { for (i = 0; i < BLOCK_WIDTH; i++) { pixels[i + j * BLOCK_WIDTH] = computePoint(i, j + myJobStart / 1536); //fprintf(stderr,"%d ",pixels[i + j * BLOCK_WIDTH]); } } // tell master work is done and ready to send mySendArr[0] = -2; MPI_Send(mySendArr,1,MPI_INT,0,0,MPI_COMM_WORLD); // send work mySendArr[0] = myJobStart; for (i = 1; i < BLOCK_WIDTH * BLOCK_HEIGHT + 1; i++) { mySendArr[i] = pixels[i-1]; } MPI_Send(mySendArr,BLOCK_WIDTH * BLOCK_HEIGHT + 1,MPI_INT,0,0,MPI_COMM_WORLD); } } //fprintf(stderr,"\t(%d) I'm finished\n",iproc); } MPI_Finalize(); return 0; }
void BezierPatch::calculatePoints() { float dt=0.06; pointCounter = 0; //draw columns for(float i=0;i<1.01f;i+=u) { for(float j=0;j<1.01f +dt/2;j+=dt) { if(j>1) j= 1.0f; pointToDraw = vec4(computePoint(i,j),1); if(!camera->isStereoscopic){ pointToDraw = camera->transformationMatrix* pointToDraw; pointToDraw.x = pointToDraw.x / pointToDraw.w; pointToDraw.y = pointToDraw.y / pointToDraw.w; pointToDraw.x /= camera->xRatio; pointToDraw.y /= camera->yRatio; pixelVector[pointCounter] = vec4(pointToDraw); pointCounter++; } else{ vec4 point2 = vec4(pointToDraw); pointToDraw = camera->transformationMatrixLeftEye * pointToDraw; pointToDraw.x /= pointToDraw.w; pointToDraw.y /= pointToDraw.w; pointToDraw.x /= camera->xRatio; pointToDraw.y /= camera->yRatio; leftEyePixelVector[pointCounter] = vec4(pointToDraw); point2 = camera->transformationMatrixRightEye * point2; point2.x /= point2.w; point2.y /= point2.w; point2.x /= camera->xRatio; point2.y /= camera->yRatio; rightEyePixelVector[pointCounter] = vec4(point2); pointCounter++; } if(j==1.0f)break; } } for(float i=0;i<1.01f;i+=v) { for(float j=0;j<1.01f+dt/2;j+=dt) { if(j>1) j= 1.0f; pointToDraw = vec4(computePoint(j,i),1); if(!camera->isStereoscopic){ pointToDraw = camera->transformationMatrix* pointToDraw; pointToDraw.x = pointToDraw.x / pointToDraw.w; pointToDraw.y = pointToDraw.y / pointToDraw.w; pointToDraw.x /= camera->xRatio; pointToDraw.y /= camera->yRatio; pixelVector[pointCounter] = vec4(pointToDraw); pointCounter++; } else{ vec4 point2 = vec4(pointToDraw); pointToDraw = camera->transformationMatrixLeftEye * pointToDraw; pointToDraw.x /= pointToDraw.w; pointToDraw.y /= pointToDraw.w; pointToDraw.x /= camera->xRatio; pointToDraw.y /= camera->yRatio; leftEyePixelVector[pointCounter] = vec4(pointToDraw); point2 = camera->transformationMatrixRightEye * point2; point2.x /= point2.w; point2.y /= point2.w; point2.x /= camera->xRatio; point2.y /= camera->yRatio; rightEyePixelVector[pointCounter] = vec4(point2); pointCounter++; } if(j==1.0f)break; } } }