C++ GImage::height方法代码示例

	void DrawCar()
	{
		double angle = atan(3 * (2 * m_carPos - 3 * m_carPos * m_carPos));
		m_pRotatedCar->rotate(m_pCar, 35, 41, angle);
		double y = m_carPos * m_carPos - m_carPos * m_carPos * m_carPos;
		int i = (int)((m_carPos + 0.4) * m_pImage->width() / 1.4);
		int j = (int)(m_pImage->height() - y * 3 * m_pImage->height() - 50);
		GRect r(0, 0, 70, 60);
		m_pImage->blitAlpha(i - 35, j - 40, m_pRotatedCar, &r);
	}

void Image4uint8::copyGImage(const GImage& im) {
    switch (im.channels()) {
    case 1:
        copyArray(im.pixel1(), im.width(), im.height());
        break;

    case 3:
        copyArray(im.pixel3(), im.width(), im.height());
        break;

    case 4:
        copyArray(im.pixel4(), im.width(), im.height());
        break;
    } 
}

Image4uint8::Ref Image4uint8::fromGImage(const GImage& im, WrapMode wrap) {
    switch (im.channels()) {
    case 1:
        return fromArray(im.pixel1(), im.width(), im.height(), wrap);

    case 3:
        return fromArray(im.pixel3(), im.width(), im.height(), wrap);

    case 4:
        return fromArray(im.pixel4(), im.width(), im.height(), wrap);

    default:
        debugAssertM(false, "Input GImage must have 1, 3, or 4 channels.");
        return NULL;
    }
}

	HelloDialog(HelloController* pController, int w, int h)
	: GWidgetDialog(w, h, 0xff90d0f0) // a=ff, r=90, g=d0, b=f0
	{
		m_pController = pController;
		m_pImage = new GImage();
		m_pImage->setSize(800, 600);
		m_pCanvas = new GWidgetCanvas(this, 10, 30, m_pImage->width(), m_pImage->height(), m_pImage);
		m_pQuitButton = new GWidgetTextButton(this, 850, 300, 80, 24, "Quit");
	}

	PopupView(GWidgetDialog* pDialog)
	: ViewBase()
	{
		m_nLeft = 0;
		m_nTop = 0;
		m_pBackgroundImage = new GImage();
		captureScreen(m_pBackgroundImage);
		m_pBackgroundImage->contrastAndBrightness(.5, -64);
		m_pDialog = pDialog;
		m_x = (m_pBackgroundImage->width() - m_pDialog->rect()->w) / 2;
		m_y = (m_pBackgroundImage->height() - m_pDialog->rect()->h) / 2;
	}

	void Redraw(bool forw)
	{
		m_pImage->clear(0xff80c0e0);

		// Draw the hill
		{
			int i, j;
			double x, y;
			for(i = 0; i < (int)m_pImage->width(); i++)
			{
				x = (double)i * 1.4 / m_pImage->width() - 0.4;
				y = x * x - x * x * x;
				j = (int)(m_pImage->height() - y * 3 * m_pImage->height() - 50);
				m_pImage->lineNoChecks(i, j, i, m_pImage->height() - 1, 0xff40a060);
			}
		}

		// Draw the car
		DrawCar();

		// Draw the acceleration arrow
		m_pImage->arrow(240, 20, 240 + (forw ? 15 : -15), 20, 0xff000000, 10);
	}

	CarOnHillDialog(CarOnHillController* pController, int w, int h)
	: GWidgetDialog(w, h, 0xff90d0f0)
	{
		m_pController = pController;

		m_pBullets = new GWidgetBulletGroup(this, 820, 102, 14, 14, 2, 30, true);
		new GWidgetTextLabel(this, 840, 100, 100, 24, "Mouse", 0xff306000);
		new GWidgetTextLabel(this, 840, 130, 100, 24, "Q-Learner", 0xff306000);
		m_pBullets->setSelection(1);

		m_pWins = new GWidgetTextLabel(this, 820, 300, 100, 24, "Wins: 0", 0xff306000, 0xff90d0f0);

		m_pUpdateDisplay = new GWidgetCheckBox(this, 820, 402, 18, 18);
		m_pUpdateDisplay->setChecked(true);
		new GWidgetTextLabel(this, 840, 400, 100, 24, "Slow", 0xff306000);

		m_pImage = new GImage();
		m_pImage->setSize(800, 600);

		m_pCanvas = new GWidgetCanvas(this, 10, 30, m_pImage->width(), m_pImage->height(), m_pImage);
		m_prng = new GRand(0);
		m_pModel = new CarOnHillModel(m_prng, m_pImage, m_pWins);
		m_bPrevUpdate = true;
	}

void G2DRegionGraph::makeCoarserRegions(G2DRegionGraph* pFineRegions)
{
	// Find every region's closest neighbor
	GImage* pFineRegionMask = pFineRegions->regionMask();
	GImage* pCoarseRegionMask = regionMask();
	GAssert(pCoarseRegionMask->width() == pFineRegionMask->width() && pCoarseRegionMask->height() == pFineRegionMask->height()); // size mismatch
	int* pBestNeighborMap = new int[pFineRegions->regionCount()];
	ArrayHolder<int> hBestNeighborMap(pBestNeighborMap);
	for(size_t i = 0; i < pFineRegions->regionCount(); i++)
	{
		struct GRegion* pRegion = pFineRegions->m_regions[i];
		struct GRegionEdge* pEdge;
		double d;
		double dBestDiff = 1e200;
		int nBestNeighbor = -1;
		for(pEdge = pRegion->m_pNeighbors; pEdge; pEdge = pEdge->GetNext(i))
		{
			size_t j = pEdge->GetOther(i);
			struct GRegion* pOtherRegion = pFineRegions->m_regions[j];
			d = MeasureRegionDifference(pRegion, pOtherRegion);
			if(d < dBestDiff)
			{
				dBestDiff = d;
				nBestNeighbor = (int)j;
			}
		}
		GAssert(nBestNeighbor != -1 || pFineRegions->regionCount() == 1); // failed to find a neighbor
		pBestNeighborMap[i] = nBestNeighbor;
	}

	// Create a mapping to new regions numbers
	int* pNewRegionMap = new int[pFineRegions->regionCount()];
	ArrayHolder<int> hNewRegionMap(pNewRegionMap);
	memset(pNewRegionMap, 0xff, sizeof(int) * pFineRegions->regionCount());
	int nNewRegionCount = 0;
	for(size_t i = 0; i < pFineRegions->regionCount(); i++)
	{
		size_t nNewRegion = -1;
		size_t j = i;
		while(pNewRegionMap[j] == -1)
		{
			pNewRegionMap[j] = -2;
			j = pBestNeighborMap[j];
		}
		if(pNewRegionMap[j] == -2)
			nNewRegion = nNewRegionCount++;
		else
			nNewRegion = pNewRegionMap[j];
		j = i;
		while(pNewRegionMap[j] == -2)
		{
			pNewRegionMap[j] = (int)nNewRegion;
			j = pBestNeighborMap[j];
		}
	}

	// Make the new regions
	for(size_t i = 0; i < pFineRegions->regionCount(); i++)
	{
		struct GRegion* pRegion = pFineRegions->m_regions[i];
		size_t j = pNewRegionMap[i];
		if(regionCount() <= j)
		{
			GAssert(regionCount() == j); // how'd it get two behind?
			addRegion();
		}
		struct GRegion* pCoarseRegion = m_regions[j];
		pCoarseRegion->m_nSumRed += pRegion->m_nSumRed;
		pCoarseRegion->m_nSumGreen += pRegion->m_nSumGreen;
		pCoarseRegion->m_nSumBlue += pRegion->m_nSumBlue;
		pCoarseRegion->m_nPixels += pRegion->m_nPixels;
	}
	for(size_t i = 0; i < pFineRegions->regionCount(); i++)
	{
		struct GRegion* pRegion = pFineRegions->m_regions[i];
		size_t j = pNewRegionMap[i];
		struct GRegionEdge* pEdge;
		for(pEdge = pRegion->m_pNeighbors; pEdge; pEdge = pEdge->GetNext(i))
		{
			size_t k = pNewRegionMap[pEdge->GetOther(i)];
			if(j != k)
				makeNeighbors(j, k);
		}
	}

	// Make the fine region mask
	unsigned int nOldRegion;
	int x, y;
	for(y = 0; y < (int)pFineRegionMask->height(); y++)
	{
		for(x = 0; x < (int)pFineRegionMask->width(); x++)
		{
			nOldRegion = pFineRegionMask->pixel(x, y);
			pCoarseRegionMask->setPixel(x, y, pNewRegionMap[nOldRegion]);
		}
	}
}