Exemplo n.º 1
0
// implement your functions here
fillerImage::fillerImage()  // constructor
{
    timesUsed = 0;
    int R = 0;
    int G = 0;
    int B = 0;
    int Height = getHeight();
    int Width = getWidth();
    int pix = Width * Height;
    
    //pixel object[Height][Width];
    for (int i = 0; i < Height; i++)
    {   
      for (int j = 0; j < Width; j++) 
      {  
         R = 0; G = 0; B = 0; 
         for(int H=0;H<Height;H++)
         {
             for(int W=0;W<Width;W++)
             {
                 R += static_cast<int>(getPixels()[i+H][j+W].red);
                 G += static_cast<int>(getPixels()[i+H][j+W].green);
                 B += static_cast<int>(getPixels()[i+H][j+W].blue);
             }
         }      
         //assign pixel average to created new image
         avgPixel.red = static_cast<unsigned char>(R/pix);
         avgPixel.green = static_cast<unsigned char>(G/pix);
         avgPixel.blue = static_cast<unsigned char>(B/pix);
      }
    }
}
Exemplo n.º 2
0
//------------------------------------------------------------------------------
// loadTexture() -- load the texture
//------------------------------------------------------------------------------
void BmpTexture::loadTexture()
{
   // If needed, read the BMP file
   if (getPixels() == 0) readFile();
    
   // Load the texture
   if (getPixels() != 0) BaseClass::loadTexture();
}
screen_buffer_t ConfigWindow::draw(TCOContext *emuContext)
{
	screen_buffer_t buffer;
	unsigned char *pixels;
	int stride;
	if (!getPixels(&buffer, &pixels, &stride)) {
		return 0;
	}

	int y=0,x=0;
	unsigned char c;
	const int cell_size = 16;
	for (y=0; y<m_size[1]; y++) {
		int t = y & cell_size;
		int h = y * stride;
		for (x=0; x < m_size[0]; x++) {
			int p = x * 4;
			c = ((x & cell_size) ^ t) ? 0xa0 : 0x80;
			pixels[h + p + 0] = c;
			pixels[h + p + 1] = c;
			pixels[h + p + 2] = c;
			pixels[h + p + 3] = 0xa0;
		}
	}

	emuContext->drawControls(buffer);
	return buffer;
}
Exemplo n.º 4
0
SpriteFrame::SpriteFrame(AccessEngine *vm, Common::SeekableReadStream *stream, int frameSize) {
	int xSize = stream->readUint16LE();
	int ySize = stream->readUint16LE();

	if (vm->getGameID() == GType_MartianMemorandum) {
		int size = stream->readUint16LE();
		if (size != frameSize)
			warning("Unexpected file difference: framesize %d - size %d %d - unknown %d", frameSize, xSize, ySize, size);
	}
	create(xSize, ySize);

	// Empty surface
	byte *data = (byte *)getPixels();
	Common::fill(data, data + w * h, TRANSPARENCY);

	// Decode the data
	for (int y = 0; y < h; ++y) {
		int offset = stream->readByte();
		int len = stream->readByte();
		assert((offset + len) <= w);

		byte *destP = (byte *)getBasePtr(offset, y);
		stream->read(destP, len);
	}
}
Exemplo n.º 5
0
/****************************************************************
 * Fills Maze Image with pixels determined by the mazeGen algo
 ****************************************************************/
void PhotoMaze :: fillImage(){

    int                _w = mazeImage.width;
    int                _h = mazeImage.height;
    int              type = mazeImage.type;
    int               bpp = images[0].bpp / 8;
    int             cellW = w/rw,
                    cellH = h/rh;
    unsigned char *pixels = mazeImage.getPixels();

    for (int i = 0; i < rw; i++){
        for (int j = 0; j < rh; j++){
            int x1 = i*cellW, y1 = j*cellH;
            
            PhotoMazeCell cell = cells[INDEX(i, j)];
            unsigned char *tempPixels = getPixels(cell.photoIndex, cell.position.x*cellW, cell.position.y*cellH, cellW, cellH);
            for (int x0 = x1; x0 < x1+cellW; x0++)
                for (int y0 = y1; y0 < y1+cellH; y0++){
                    pixels[(x0+y0*_w)*3 ]   = tempPixels[(x0-x1+(y0-y1)*cellW)*3 ];
                    pixels[(x0+y0*_w)*3+1 ] = tempPixels[(x0-x1+(y0-y1)*cellW)*3+1 ];
                    pixels[(x0+y0*_w)*3+2 ] = tempPixels[(x0-x1+(y0-y1)*cellW)*3+2 ];
                }
            delete tempPixels;
        }
    }
    mazeImage.reloadTexture();   
}
void ofxThreadedImage::resizeIfNeeded(){
	if (resizeAfterLoad){
		int w = getWidth();
		int h = getHeight();
		int largestSide = MAX(w, h);
		if(largestSide > maxSideSize){ //we need resize!
			float scale = maxSideSize / (float)largestSide;
			//float t1 = ofGetElapsedTimef();
			int newW = w * scale;
			int newH = h * scale;
			#if USE_OPENCV_TO_RESIZE
			if (type == OF_IMAGE_COLOR){
				ofxCvColorImage cvImg;
				cvImg.setUseTexture(false);
				cvImg.allocate(w, h);
				cvImg.setFromPixels(getPixels(), w, h);
				ofxCvColorImage cvImgsmall;
				cvImgsmall.setUseTexture(false);
				cvImgsmall.allocate(newW, newH);
				cvImgsmall.scaleIntoMe(cvImg, CV_INTER_AREA);
				setFromPixels(cvImgsmall.getPixels(), newW, newH, OF_IMAGE_COLOR);
			}else{
				resize(newW, newH); //TODO opencv resizing is much faster!
			}
			#else
			resize(newW, newH); //TODO opencv resizing is much faster!
			#endif
			//ofLog() << "time resize: " + ofToString( ofGetElapsedTimef() - t1 );
		}
	}
}
const vector<short> & ofxDepthCompressedFrame::compressedData(){
	if(compressedDirty){
		compressed.resize(getPixels().size()*2+5);
		if(!isKeyFrame()){
			uncompressedDiff.clear();
			int lastPos = 0;
			for(int i=0;i<pixels.size();i++){
				int pos = i-lastPos;
				if(pixels[i]==0 && pos < std::numeric_limits<unsigned short>::max()) continue;
                DiffPixel diffPixel={(unsigned short)pos,pixels[i]};
				uncompressedDiff.push_back(diffPixel);
				lastPos = i;
			}
			if(uncompressedDiff.empty()){
				compressedBytes = 0;
			}else{
				compressedBytes = ofx_compress((unsigned char*)&uncompressedDiff[0],uncompressedDiff.size()*sizeof(DiffPixel),(unsigned char*)&compressed[5]);
			}
		}else{
			compressedBytes = ofx_compress((unsigned char*)pixels.getPixels(),pixels.size()*sizeof(short),(unsigned char*)&compressed[5]);
		}
		compressedDirty = false;
		compressed.resize(compressedBytes/2+5);
	}
	return compressed;
}
Exemplo n.º 8
0
/* rotate image by 90° */
IplImage * rotate ( IplImage * img, uchar *** pixels ) {

    int width		= img->width,
    	height		= img->height,
    	depth		= img->depth,
    	channels	= img->nChannels;

	IplImage *out = NULL;
	out = cvCreateImage( cvSize(height,width), depth, channels );

	uchar *** nPixels = NULL;
	nPixels = getPixels( out );

	int nY, nX, 	// temp
		x, y, c;	// iterator

	// set values
    for ( y = 0; y < height; y++ ) {
    	for ( x = 0; x < width; x++ ) {

 			nY = width - 1 - x;
 			nX = y;

     		for ( c = 0; c < channels; c++ ) nPixels[nY][nX][c] = pixels[y][x][c];
		}
	}

	/* using cv */
	// cvTranspose( img, out );
	// cvFlip( out, NULL, 0 );

	return out;
}
Exemplo n.º 9
0
void Screen::randomTransition() {
	Events &events = *_vm->_events;
	const int TRANSITION_MULTIPLIER = 0x15a4e35;
	clearDirtyRects();
	assert(IS_SERRATED_SCALPEL);

	for (int idx = 0; idx <= 65535 && !_vm->shouldQuit(); ++idx) {
		_transitionSeed = _transitionSeed * TRANSITION_MULTIPLIER + 1;
		int offset = _transitionSeed & 0xFFFF;

		if (offset < (this->width() * this->height()))
			*((byte *)getPixels() + offset) = *((const byte *)_backBuffer.getPixels() + offset);

		if (idx != 0 && (idx % 300) == 0) {
			// Ensure there's a full screen dirty rect for the next frame update
			if (!isDirty())
				addDirtyRect(Common::Rect(0, 0, this->w, this->h));

			events.pollEvents();
			events.delay(1);
		}
	}

	// Make sure everything has been transferred
	SHblitFrom(_backBuffer);
}
///--------------------------------------------------------------
void PMMotionExtractor::draw(bool drawImage, bool drawHands)
{
	if (hasKinect && drawImage) {
		auto infraredImage = kinect.getInfraredSource();
		auto infraredPixels = infraredImage->getPixels();
		for (auto & pixel : infraredPixels) {
			pixel += pixel * 2;
		}
		ofTexture drawTexture;
		drawTexture.allocate(512, 424, GL_LUMINANCE);
		drawTexture.loadData(infraredPixels);
		drawTexture.draw(0, 0, ofGetWidth(), ofGetHeight());
	}
    if(drawHands){
        ofPushStyle();
        ofNoFill();
        ofSetLineWidth(3);
        ofSetColor(ofColor::red);
        ofDrawEllipse(handsInfo.rightHand.pos.x * ofGetWidth(), handsInfo.rightHand.pos.y * ofGetHeight(), 20+20*(handsInfo.rightHand.v.x), 20+20*(handsInfo.rightHand.v.y));
        ofDrawEllipse(handsInfo.leftHand.pos.x * ofGetWidth(), handsInfo.leftHand.pos.y * ofGetHeight(), 20+20*(handsInfo.leftHand.v.x),20+20*(handsInfo.leftHand.v.y));
		//ofDrawBitmapString(handsInfo.rightHand.pos.z, handsInfo.rightHand.pos.x * ofGetWidth() + 10, handsInfo.rightHand.pos.y * ofGetHeight() + 10);
		//ofDrawBitmapString(handsInfo.leftHand.pos.z, handsInfo.leftHand.pos.x * ofGetWidth() + 10, handsInfo.leftHand.pos.y * ofGetHeight() + 10);
        ofPopStyle();
    }
	ofDrawBitmapString(positionDetectedCounter, 0, 0);
}
Exemplo n.º 11
0
//--------------------------------------------------------
void Pixelgroup::paint(PixelWriterInterface& writer)
{
  // safeties
  if (!isDirty() && !m_isFlickering) return;
  if (getPixels() == 0 || getSize() == 0) return;
  
  
  bool strobeState = !Strobe::isStrobing() || Strobe::getStrobeState();
  bool flickeringDone = false;
  
  
  // mark as clean
  setDirty(false);
  
  
  for (uint8_t i=0; i<getSize(); i++) {
  
    uint8_t pixelIndex = getPixels()[i];
  
    if (m_isFlickering > 0 &&
      !flickeringDone)
    {
#ifdef ESP8266
      if ((rand() % 100) > 80) {
#else
      if ((random() % 100) > 80) {
#endif
        strobeState &= 0;
        flickeringDone = true;
        m_isFlickering--;
    
        // mark as dirty to redraw on next cycle
        setDirty(true);
      }    
    }
  
    // set pixel color (or black)
    // sets color in pixelWriter
    // sets pixelwriter to dirty
    if (!strobeState || flickeringDone) {
      writer.setPixelColor(pixelIndex, 0, 0, 0);
    } else { 
      writer.setPixelColor((uint8_t)pixelIndex, getR(), getG(), getB());
    }
  }
}
Exemplo n.º 12
0
void ScreenSurface::init() {
	// Set the size for the screen
	setSize(MADS_SCREEN_WIDTH, MADS_SCREEN_HEIGHT);

	// Store a copy of the raw pixels pointer for the screen, since the surface
	// itself may be later changed to only a subset of the screen
	_surfacePixels = (byte *)getPixels();
	_freeFlag = false;
}
Exemplo n.º 13
0
int main ( int argc, char * argv[] ) {

	if ( argc < 2 ) errorMessage( 1, "Missing Arguments" );
	if ( argc > 3 ) errorMessage( 2, "Too many Arguments" );

	IplImage *img = NULL;
	img = cvLoadImage( argv[1], 1 );

	// pixels [y][x][c]
	uchar *** pixels = NULL;
	pixels = getPixels( img );

	char key;

	do {

		key = (char) cvWaitKey(1);

		if ( key == 'n' ) normalize( img, pixels );
		if ( key == 'i' ) invert( img, pixels );
		if ( key == 'h' ) cvFlip( img, img, 1 );

		if ( key == 'l' ) {

			IplImage *tmp = NULL;
			tmp = rotate( img, pixels );

			freePixels( img->height, pixels );
			cvReleaseImage( &img );

			img = tmp;
			pixels = getPixels( img );
		}

		cvShowImage("rgbviewer", img );

	} while ( key != 'q' ); // quit

	// release the image & reference ( tmp )
	freePixels( img->height, pixels );
	cvReleaseImage( &img );

	return 0;
}
Exemplo n.º 14
0
		//----------
		shared_ptr<Frame> NullDevice::getFrame() {
			ofSleepMillis(1e3 / this->settings.frameRate);

			auto frame = FramePool::X().getAvailableAllocatedFrame(this->settings.width, this->settings.height, OF_PIXELS_MONO);
			frame->getPixels().set(0, 0);
			frame->setFrameIndex(this->frameIndex++);
			frame->setTimestamp(chrono::high_resolution_clock::now() - this->startTime);

			return frame;
		}
Exemplo n.º 15
0
const int Text::width(char character)
{
  int character_width = 0;
  uint32_t pixels = getPixels(character);
  while (pixels > 1) {
    character_width += 1;
    pixels >>= CHARACTER_HEIGHT;
  }
  return character_width;
}
Exemplo n.º 16
0
//--------------------------------------------------------------------------------
void ofxCvImage::updateTexture(){
	if(!bAllocated) {
		ofLogWarning("ofxCvImage") << "updateTexture(): image not allocated";	
	} else if(bUseTexture ) {
		if( bTextureDirty ) {
			tex.loadData( getPixels() );
			bTextureDirty = false;
		}
	}
}
Exemplo n.º 17
0
void Scalpel3DOScreen::blitFrom3DOcolorLimit(uint16 limitColor) {
	uint16 *currentScreenPtr = (uint16 *)getPixels();
	uint16 *targetScreenPtr = (uint16 *)_backBuffer.getPixels();
	uint16  currentScreenPixel = 0;

	uint16  screenWidth = SHERLOCK_SCREEN_WIDTH;
	uint16  screenHeight = SHERLOCK_SCREEN_HEIGHT;
	uint16  screenX = 0;
	uint16  screenY = 0;

	uint16  currentScreenPixelRed = 0;
	uint16  currentScreenPixelGreen = 0;
	uint16  currentScreenPixelBlue = 0;

	uint16  limitPixelRed = limitColor & 0xF800;
	uint16  limitPixelGreen = limitColor & 0x07E0;
	uint16  limitPixelBlue = limitColor & 0x001F;

	for (screenY = 0; screenY < screenHeight; screenY++) {
		for (screenX = 0; screenX < screenWidth; screenX++) {
			currentScreenPixel = *targetScreenPtr;

			currentScreenPixelRed = currentScreenPixel & 0xF800;
			currentScreenPixelGreen = currentScreenPixel & 0x07E0;
			currentScreenPixelBlue = currentScreenPixel & 0x001F;

			if (currentScreenPixelRed < limitPixelRed)
				currentScreenPixelRed = limitPixelRed;
			if (currentScreenPixelGreen < limitPixelGreen)
				currentScreenPixelGreen = limitPixelGreen;
			if (currentScreenPixelBlue < limitPixelBlue)
				currentScreenPixelBlue = limitPixelBlue;

			uint16 v = currentScreenPixelRed | currentScreenPixelGreen | currentScreenPixelBlue;
			*currentScreenPtr = v;
			if (_vm->_isScreenDoubled) {
				*(currentScreenPtr + 1) = v;
				*(currentScreenPtr + 640) = v;
				*(currentScreenPtr + 640 + 1) = v;
			}

			currentScreenPtr += _vm->_isScreenDoubled ? 2 : 1;
			targetScreenPtr++;
		}

		if (_vm->_isScreenDoubled)
			currentScreenPtr += 640;
	}

	// Too much considered dirty at the moment
	if (_vm->_isScreenDoubled)
		addDirtyRect(Common::Rect(0, 0, screenWidth * 2, screenHeight * 2));
	else
		addDirtyRect(Common::Rect(0, 0, screenWidth, screenHeight));
}
Exemplo n.º 18
0
void P6::Monochrome(const char* filename)
{
	if (isGrayMonochrome() == true)
	{
		cout << "The image is already monochrome \n";
		return;
	}
	else
	{
		char* newName = ChangeFileName(filename, "_monochrome.ppm");
		ofstream outFile(newName, ios::out);
		if (!outFile)
		{
			cerr << "Cannot write P6 file \n";
			return;
		}
		char magic_pbm[3] = "P6";
		outFile << magic_pbm << endl << getWidth() << " " << getHeight() << endl << getMaxNum() << endl;

		int r = 0, g = 0, b = 0;
		for (int i = 0; i < getHeight(); i++)
		{
			for (int j = 0; j < getWidth(); j++)
			{
				r = getPixels()[i][j].getRed();
				g = getPixels()[i][j].getGreen();
				b = getPixels()[i][j].getBlue();

				int gray = grayscale(r, g, b);
				int m = monochrome(gray);

				outFile.write((const char*)&m, sizeof(char));
				outFile.write((const char*)&m, sizeof(char));
				outFile.write((const char*)&m, sizeof(char));
			}
		}

		outFile.flush();
		outFile.close();
		delete[] newName;
	}
}
Exemplo n.º 19
0
		//---------
		shared_ptr<Frame> VideoInput::getFrame() {
			auto frame = FramePool::X().getAvailableAllocatedFrame(this->device->getWidth(this->deviceIndex)
				, this->device->getHeight(this->deviceIndex)
				, ofPixelFormat::OF_PIXELS_RGB);

			this->device->getPixels(this->deviceIndex, frame->getPixels().getData(), true, true);

			frame->setTimestamp(chrono::high_resolution_clock::now() - this->timerStart);
			frame->setFrameIndex(this->frameIndex);
			return frame;
		}
Exemplo n.º 20
0
//--------------------------------------------------------------------------------
void ofxCvFloatImage::drawWithScale( float x, float y, float w, float h, float scaleMin, float scaleMax){
    if( bUseTexture ) {
        // note, this is a bit ineficient, as we have to
        // copy the data out of the cvImage into the pixel array
        // and then upload to texture.  We should add
        // to the texture class an override for pixelstorei
        // that allows stepped-width image upload:
        tex.loadData(getPixels(scaleMin, scaleMax), width, height, GL_LUMINANCE);
        tex.draw(x,y,w,h);
    }
}
Exemplo n.º 21
0
void ofxCvImage::updateTexture(){
	if( bTextureDirty ) {
		if(tex.getWidth() != width || tex.getHeight() != height) {
			//ROI was changed
			// reallocating texture - this could be faster with ROI support
			tex.clear();
			tex.allocate( width, height, glchannels );
		}
		tex.loadData( getPixels(), width, height, glchannels );
		bTextureDirty = false;
	}
}
Exemplo n.º 22
0
void 
HippoImageBuffer::tile(BITMAPINFO *bitmapInfo, void *bits, int x0, int y0, int x1, int y1)
{
    // The way we combine images is that where we have alpha == 0xff in the source
    // image, we leave the destination image untouched, otherwise we replace the
    // destination pixel with the source pixel; basically we are "fixing up" the
    // image we drew with IE, which can't handle partial alpha on the background
    // of a web page, by replacing just the partially alpha pixels

    int destWidth = bitmapInfo->bmiHeader.biWidth;
    int destHeight = - bitmapInfo->bmiHeader.biHeight;

    if (x0 < 0)
        x0 = 0;
    if (y0 < 0)
        y0 = 0;
    if (x1 > destWidth)
        x1 = destWidth;
    if (y1 > destHeight)
        y1 = destHeight;

    const UINT *srcRow = buffer_;
    UINT *destRow = (UINT *)bits + y0 * destWidth + x0;

    int j = 0;
    for (int y = y0; y < y1; y++, j++) {
        if (j == getHeight()) {
            j = 0;
            srcRow = getPixels();
        }

        const UINT *src = srcRow;
        UINT *dest = destRow;

        int i = 0;
        for (int x = x0; x < x1; x++, i++) {
            if (i == getWidth()) {
                i = 0;
                src = srcRow;
            }

            UINT srcPixel = *src;
            if ((srcPixel & 0xFF000000) != 0xFF000000)
                *dest = srcPixel;

            src++;
            dest++;
        }

        srcRow += getWidth();
        destRow += destWidth;
    }
}
const RawImage::Pixel * RawImage::getSurfacePixels(const unsigned int surfaceIndex) const
{
    assert(isValid());

    const Pixel * pixelsStart = getPixels();
    for (unsigned int s = 0; s < surfaceIndex; ++s)
    {
        pixelsStart += getSurfacePixelCount(s);
    }

    return pixelsStart;
}
Exemplo n.º 24
0
//Grab frame from GPU
void ofxKCoreVision::grabFrameToGPU(GLuint target){
	//grab the frame to a raw openGL texture
	getPixels();

	glEnable(GL_TEXTURE_2D);
	//glPixelStorei(1);
	glBindTexture(GL_TEXTURE_2D, target);
	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, camWidth, camHeight, GL_RGB, GL_UNSIGNED_BYTE, sourceImg.getPixels());
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glBindTexture(GL_TEXTURE_2D,0);
}
Exemplo n.º 25
0
bool ImageRAW::load(std::string filename)
{
	m_bLoaded = 0;

    if (!sofa::helper::system::DataRepository.findFile(filename))
    {
        std::cerr << "File " << filename << " not found " << std::endl;
        return false;
    }
    FILE *file;
    /* make sure the file is there and open it read-only (binary) */
    if ((file = fopen(filename.c_str(), "rb")) == NULL)
    {
        std::cerr << "File not found : " << filename << std::endl;
        return false;
    }

    // read header and ignore it as we don't know how to interpret it
    for ( unsigned i=0; i<headerSize; ++i )
    {
        int c = getc ( file );

        if ( c == EOF )
        {
            fclose ( file );
            return false;
        }
        else
            header[i] = ( unsigned char ) c;
    }

    const unsigned int numVoxels = getImageSize();

    // get the voxels from the file
    unsigned char *data = getPixels();
    for ( unsigned int i=0; i<numVoxels; ++i )
    {
        int c = getc ( file );

        if ( c == EOF )
        {
            fclose ( file );
            return false;
        }
        else
            data[i] = ( unsigned char ) c;
    }

    fclose(file);
	m_bLoaded = 1;
    return true;
}
Exemplo n.º 26
0
//-----------------------------------------------------------------------------------
void ofxCairoTexture::update(){
	
	if( surface == NULL ) {
		printf("Error: ofxCairoTexture not allocated\n");
		return;
	}
	
	int w = getWidth(); 
	int h = getHeight(); 
	unsigned char * pix = getPixels();
	
	tex.setFromPixels(pix, w, h, OF_IMAGE_COLOR_ALPHA, false);
}
Exemplo n.º 27
0
void P6::Grayscale(const char* filename)
{
	if (isGrayMonochrome() == true)
	{
		cout << "The image is already grayscale \n";
		return;
	}
	else
	{
		char* newName = ChangeFileName(filename, "_grayscale.ppm");
		ofstream outFile(newName, ios::out | ios::binary);
		if (!outFile)
		{
			cerr << "Cannot write P6 file \n";
			return;
		}
		char magic_pgm[3] = "P6";
		outFile << magic_pgm << endl << width << " " << height << endl << max_num << endl;

		for (int i = 0; i < getHeight(); i++)
		{
			for (int j = 0; j < getWidth(); j++)
			{
				r = getPixels()[i][j].getRed();
				g = getPixels()[i][j].getGreen();
				b = getPixels()[i][j].getBlue();

				int gray = grayscale(r, g, b);
				outFile.write((const char*)&gray, sizeof(Color) / 3);
				outFile.write((const char*)&gray, sizeof(Color) / 3);
				outFile.write((const char*)&gray, sizeof(Color) / 3);
			}
		}
		outFile.flush();
		outFile.close();
		delete[] newName;
	}	
}
Exemplo n.º 28
0
//--------------------------------------------------------------------------------
void ofxCvImage::draw( float x, float y, float w, float h ) {
    if( bUseTexture ) {
        if( bTextureDirty ) {
            if(tex.getWidth() != width || tex.getHeight() != height) {
                //ROI was changed
                // reallocating texture - this could be faster with ROI support
                tex.clear();
                tex.allocate( width, height, glchannels );
            }
            tex.loadData( getPixels(), width, height, glchannels );
            bTextureDirty = false;
        }

        tex.draw(x,y, w,h);

    } else {
        #ifdef TARGET_OPENGLES
            ofLog(OF_LOG_ERROR, "texture-less drawing not supported in OpenGL ES");
        #else
            // this is slower than the typical draw method based on textures
            // but useful when dealing with threads GL textures often don't work
            ofLog(OF_LOG_NOTICE, "in draw, using slow texture-less drawing");
            ofLog(OF_LOG_NOTICE, "texture-less drawing - be aware, unlike texture drawing, \
                              this always draws window aligned, rotation not supported");

            if( x == 0) {
                x += 0.01;
                ofLog(OF_LOG_NOTICE, "BUG: can't draw at x==0 in texture-less mode.");
            }

            if(bAnchorIsPct){
                x -= anchor.x * w;
                y -= anchor.y * h;
            }else{
                x -= anchor.x;
                y -= anchor.y;
            }

            glRasterPos2f( x, y+h );

            IplImage* tempImg;
            tempImg = cvCreateImage( cvSize((int)w, (int)h), ipldepth, iplchannels );
            cvResize( cvImage, tempImg, CV_INTER_NN );
            cvFlip( tempImg, tempImg, 0 );
            glDrawPixels( tempImg->width, tempImg->height ,
                          glchannels, gldepth, tempImg->imageData );
            cvReleaseImage( &tempImg );
        #endif
    }
}
Exemplo n.º 29
0
void ASurface::transBlitFrom(ASurface *src, const Common::Point &destPos) {
	if (getPixels() == nullptr)
		create(w, h);

	for (int yp = 0; yp < src->h; ++yp) {
		const byte *srcP = (const byte *)src->getBasePtr(0, yp);
		byte *destP = (byte *)getBasePtr(destPos.x, destPos.y + yp);

		for (int xp = 0; xp < this->w; ++xp, ++srcP, ++destP) {
			if (*srcP != TRANSPARENCY)
				*destP = *srcP;
		}
	}
}
Exemplo n.º 30
0
bool Image::crop(const Rect& region)
{
    std::vector<Color> pixels;
    if(!getPixels(pixels, region))
    {
        return false;
    }

    _width = (int)region.width;
    _height = (int)region.height;
    _pixels.resize(pixels.size());
    std::copy(pixels.begin(), pixels.end(), _pixels.begin());

    return true;
}