C++ Pixel::getG方法代码示例

DTFrame* ServerClientProxy::buildFrameToTransmit(){
    vector<Pixel*>::iterator it;
	it=this->pixelsFast.begin();
    
	vector<DTPixel*>* dtVector = new vector<DTPixel*>();
    
    int size=this->pixelsFast.size();
    
    cl_float* newPixelArray = new cl_float[size * 4];
    int cont=0;
	while (it != this->pixelsFast.end())
	{
        Pixel* px = *it;

        int pId = px->getId();
        float pR = px->getR();
        float pG = px->getG();
        float pB = px->getB();
        float pA = px->getA();
        
        DTPixel * pixelForNewFrame= px->getDTPixel();
		
        dtVector->push_back(pixelForNewFrame);
        
        newPixelArray[(cont*4)] = (cl_float)pR;
        newPixelArray[(cont*4)+1] = (cl_float)pG;
        newPixelArray[(cont*4)+2] = (cl_float)pB;
        newPixelArray[(cont*4)+3] = (cl_float)pA;
        cont++;
		it++;
	}
	return new DTFrame(0, dtVector, newPixelArray, this->pixelsFast.size(), 0);
}

Pixel::Pixel(Pixel &p)
{
    this->_r = p.getR();
    this->_g = p.getG();
    this->_b = p.getB();
    this->_a = p.getA();
}

void ServerClientProxy::draw(float x, float y, float w, float h){ //not used anymore since Clients do not render on the server UI
	if(drawEnabled){
        glViewport(x, ofGetHeight()-y-h, w-1, h-1);  
              
        // all the matrix setup is copied from the ofGraphics.cpp::void ofSetupScreen() method.  
        float halfFov, theTan, screenFov, aspect;  
        screenFov       = 60.0f;  
        float eyeX      = (float)w / 2.0;  
        float eyeY      = (float)h / 2.0;  
        halfFov         = PI * screenFov / 360.0;  
        theTan          = tanf(halfFov);  
        float dist      = eyeY / theTan;  
        float nearDist  = dist / 10.0;  // near / far clip plane  
        float farDist   = dist * 10.0;  
        aspect          = (float)w/(float)h;  
          
        glMatrixMode(GL_PROJECTION);  
        glLoadIdentity();  
        gluPerspective(screenFov, aspect, nearDist, farDist);  
          
        glMatrixMode(GL_MODELVIEW);  
        glLoadIdentity();  
        gluLookAt(eyeX, eyeY, dist, eyeX, eyeY, 0.0, 0.0, 1.0, 0.0);  
          
        glClear(GL_DEPTH_BUFFER_BIT);  
                  
        glScalef(1, -1, 1);           // invert Y axis so increasing Y goes down.  
        glTranslatef(10, -y-h+10, 0);       // shift origin up to upper-left corner.  

        
        // draw the pixels  
        //ofTranslate(translation.x, translation.y, translation.z);
        ofTranslate(centroid.x, centroid.y, centroid.z);
        ofRotateX(this->rotX);
        ofRotateZ(this->rotY);
        ofTranslate(-centroid.x, -centroid.y, -centroid.z);
        glScalef(scale, scale, scale);
        
        vector<Pixel*>::iterator it = this->pixelsFast.begin();
        while (it!=this->pixelsFast.end())
        {
            Pixel* px = *it;
            ofVec3f position = px->getPosition();
            glPushMatrix();
            glTranslatef(position.x, position.y, position.z);
            ofSetColor(px->getR(),px->getG(), px->getB());
            glCallList(this->displayList);
            glPopMatrix();
            it++;
        } 
          
        // reset viewport back to main screen  
        glFlush(); 
    }
}

/*
 *
 * 普通灰度变换
 *
 */
void Gray::normalGray()
{
    for(int y=0;y<this->mat->getHeight();y++){
        for (int x = 0; x < this->mat->getWidth(); x++) {
            Pixel * pixel = this->mat->getPixel(x,y);
            uint32_t R = pixel->getR();
            uint32_t G = pixel->getG();
            uint32_t B = pixel->getB();

            uint32_t gray = (R*19595 + G*38469 + B*7472) >> 16;

            pixel->setPixel(gray,gray,gray);
            delete (pixel);
        }
    }
}

void Gray::gamma(double c,double _y)
{
    for(int y=0;y<this->mat->getHeight();y++){
        for (int x = 0; x < this->mat->getWidth(); x++) {
            Pixel * pixel = this->mat->getPixel(x,y);
            uint32_t R = pixel->getR();
            uint32_t G = pixel->getG();
            uint32_t B = pixel->getB();

            uint32_t gray = (R*19595 + G*38469 + B*7472) >> 16;

            gray = c * (pow(gray,_y));

            pixel->setPixel(gray,gray,gray);
            delete (pixel);
        }
    }
}

void Pixel::add(Pixel p) {
    this->setR(r+p.getR());
    this->setG(g+p.getG());
    this->setB(b+p.getB());
}

void GenericClientManager::transmitFrame() {
    //construyo DTFrame en base a los pixels mezclados

    if(this->waitForReceiver==0) { // envio solo si el server no me pidio esperarpor error

        vector<DTPixel*>* newVector = new vector<DTPixel*>;
        map<int,Pixel*>::iterator it = this->pixels->begin();
        while (it!=this->pixels->end())
        {
            Pixel* px = it->second;
            ofVec3f position = px->getPosition();
            ofVec3f front = px->getFront();
            ofVec3f up = px->getUp();
            string modelName = px->getModelName();
            DTPixel* dtPix = new DTPixel(px->getId(), px->getR(), px->getG(), px->getB(), px->getA(), position.x, position.y, position.z, front, up, modelName);

            newVector->push_back(dtPix);

            it++;
        }
        DTFrame * newFrame = new DTFrame(0, newVector, this->pixels->size() , this->sequenceNumber);

        // slice the DTFrame and transmit by piece.

        int pixelQuantity = newVector->size();
        int minId=0;
        int maxId=pixelQuantity-1;

        while(pixelQuantity>0) {
            celebra_packet_t toTransmit;
            int headerSize =18;
            if (pixelQuantity<=341) {
                toTransmit=newFrame->getBinaryPacketFromFrame(minId, maxId, this->sequenceNumber, 1);
                int sent = this->udpManager.SendAll((char *)&toTransmit, headerSize+((maxId-minId+1)*3));
                pixelQuantity=0;
            }
            else {

                toTransmit=newFrame->getBinaryPacketFromFrame(minId, minId+340, this->sequenceNumber, 0);
                int sent = this->udpManager.SendAll((char *)&toTransmit, headerSize+(341*3));
                pixelQuantity=pixelQuantity-341;
                minId = minId + 341;
            }

            // must increment sequence number.
            if (this->sequenceNumber==65535) {
                this->sequenceNumber=0;
            }
            else {
                this->sequenceNumber++;
            }

        }

        delete newFrame;
    }
    else {
        this->waitForReceiver-=1;
    }

}