Exemple #1
0
static bool read_jpeg_image(QImage *outImage,
                            QSize scaledSize, QRect scaledClipRect,
                            QRect clipRect, volatile int inQuality, j_decompress_ptr info, struct my_error_mgr* err  )
{
    if (!setjmp(err->setjmp_buffer)) {
        // -1 means default quality.
        int quality = inQuality;
        if (quality < 0)
            quality = 75;

        // If possible, merge the scaledClipRect into either scaledSize
        // or clipRect to avoid doing a separate scaled clipping pass.
        // Best results are achieved by clipping before scaling, not after.
        if (!scaledClipRect.isEmpty()) {
            if (scaledSize.isEmpty() && clipRect.isEmpty()) {
                // No clipping or scaling before final clip.
                clipRect = scaledClipRect;
                scaledClipRect = QRect();
            } else if (scaledSize.isEmpty()) {
                // Clipping, but no scaling: combine the clip regions.
                scaledClipRect.translate(clipRect.topLeft());
                clipRect = scaledClipRect.intersected(clipRect);
                scaledClipRect = QRect();
            } else if (clipRect.isEmpty()) {
                // No clipping, but scaling: if we can map back to an
                // integer pixel boundary, then clip before scaling.
                if ((info->image_width % scaledSize.width()) == 0 &&
                        (info->image_height % scaledSize.height()) == 0) {
                    int x = scaledClipRect.x() * info->image_width /
                            scaledSize.width();
                    int y = scaledClipRect.y() * info->image_height /
                            scaledSize.height();
                    int width = (scaledClipRect.right() + 1) *
                                info->image_width / scaledSize.width() - x;
                    int height = (scaledClipRect.bottom() + 1) *
                                 info->image_height / scaledSize.height() - y;
                    clipRect = QRect(x, y, width, height);
                    scaledSize = scaledClipRect.size();
                    scaledClipRect = QRect();
                }
            } else {
                // Clipping and scaling: too difficult to figure out,
                // and not a likely use case, so do it the long way.
            }
        }

        // Determine the scale factor to pass to libjpeg for quick downscaling.
        if (!scaledSize.isEmpty() && info->image_width && info->image_height) {
            if (clipRect.isEmpty()) {
                double f = qMin(double(info->image_width) / scaledSize.width(),
                                double(info->image_height) / scaledSize.height());

                // libjpeg supports M/8 scaling with M=[1,16]. All downscaling factors
                // are a speed improvement, but upscaling during decode is slower.
                info->scale_num   = qBound(1, qCeil(8/f), 8);
                info->scale_denom = 8;
            } else {
                info->scale_denom = qMin(clipRect.width() / scaledSize.width(),
                                         clipRect.height() / scaledSize.height());

                // Only scale by powers of two when clipping so we can
                // keep the exact pixel boundaries
                if (info->scale_denom < 2)
                    info->scale_denom = 1;
                else if (info->scale_denom < 4)
                    info->scale_denom = 2;
                else if (info->scale_denom < 8)
                    info->scale_denom = 4;
                else
                    info->scale_denom = 8;
                info->scale_num = 1;

                // Correct the scale factor so that we clip accurately.
                // It is recommended that the clip rectangle be aligned
                // on an 8-pixel boundary for best performance.
                while (info->scale_denom > 1 &&
                       ((clipRect.x() % info->scale_denom) != 0 ||
                        (clipRect.y() % info->scale_denom) != 0 ||
                        (clipRect.width() % info->scale_denom) != 0 ||
                        (clipRect.height() % info->scale_denom) != 0)) {
                    info->scale_denom /= 2;
                }
            }
        }

        // If high quality not required, use fast decompression
        if( quality < HIGH_QUALITY_THRESHOLD ) {
            info->dct_method = JDCT_IFAST;
            info->do_fancy_upsampling = FALSE;
        }

        (void) jpeg_calc_output_dimensions(info);

        // Determine the clip region to extract.
        QRect imageRect(0, 0, info->output_width, info->output_height);
        QRect clip;
        if (clipRect.isEmpty()) {
            clip = imageRect;
        } else if (info->scale_denom == info->scale_num) {
            clip = clipRect.intersected(imageRect);
        } else {
            // The scale factor was corrected above to ensure that
            // we don't miss pixels when we scale the clip rectangle.
            clip = QRect(clipRect.x() / int(info->scale_denom),
                         clipRect.y() / int(info->scale_denom),
                         clipRect.width() / int(info->scale_denom),
                         clipRect.height() / int(info->scale_denom));
            clip = clip.intersected(imageRect);
        }

        // Allocate memory for the clipped QImage.
        if (!ensureValidImage(outImage, info, clip.size()))
            longjmp(err->setjmp_buffer, 1);

        // Avoid memcpy() overhead if grayscale with no clipping.
        bool quickGray = (info->output_components == 1 &&
                          clip == imageRect);
        if (!quickGray) {
            // Ask the jpeg library to allocate a temporary row.
            // The library will automatically delete it for us later.
            // The libjpeg docs say we should do this before calling
            // jpeg_start_decompress().  We can't use "new" here
            // because we are inside the setjmp() block and an error
            // in the jpeg input stream would cause a memory leak.
            JSAMPARRAY rows = (info->mem->alloc_sarray)
                              ((j_common_ptr)info, JPOOL_IMAGE,
                               info->output_width * info->output_components, 1);

            (void) jpeg_start_decompress(info);

            while (info->output_scanline < info->output_height) {
                int y = int(info->output_scanline) - clip.y();
                if (y >= clip.height())
                    break;      // We've read the entire clip region, so abort.

                (void) jpeg_read_scanlines(info, rows, 1);

                if (y < 0)
                    continue;   // Haven't reached the starting line yet.

                if (info->output_components == 3) {
                    uchar *in = rows[0] + clip.x() * 3;
                    QRgb *out = (QRgb*)outImage->scanLine(y);
                    rgb888ToRgb32ConverterPtr(out, in, clip.width());
                } else if (info->out_color_space == JCS_CMYK) {
                    // Convert CMYK->RGB.
                    uchar *in = rows[0] + clip.x() * 4;
                    QRgb *out = (QRgb*)outImage->scanLine(y);
                    for (int i = 0; i < clip.width(); ++i) {
                        int k = in[3];
                        *out++ = qRgb(k * in[0] / 255, k * in[1] / 255,
                                      k * in[2] / 255);
                        in += 4;
                    }
                } else if (info->output_components == 1) {
                    // Grayscale.
                    memcpy(outImage->scanLine(y),
                           rows[0] + clip.x(), clip.width());
                }
            }
        } else {
            // Load unclipped grayscale data directly into the QImage.
            (void) jpeg_start_decompress(info);
            while (info->output_scanline < info->output_height) {
                uchar *row = outImage->scanLine(info->output_scanline);
                (void) jpeg_read_scanlines(info, &row, 1);
            }
        }

        if (info->output_scanline == info->output_height)
            (void) jpeg_finish_decompress(info);

        if (info->density_unit == 1) {
            outImage->setDotsPerMeterX(int(100. * info->X_density / 2.54));
            outImage->setDotsPerMeterY(int(100. * info->Y_density / 2.54));
        } else if (info->density_unit == 2) {
            outImage->setDotsPerMeterX(int(100. * info->X_density));
            outImage->setDotsPerMeterY(int(100. * info->Y_density));
        }

        if (scaledSize.isValid() && scaledSize != clip.size()) {
            *outImage = outImage->scaled(scaledSize, Qt::IgnoreAspectRatio, quality >= HIGH_QUALITY_THRESHOLD ? Qt::SmoothTransformation : Qt::FastTransformation);
        }

        if (!scaledClipRect.isEmpty())
            *outImage = outImage->copy(scaledClipRect);
        return !outImage->isNull();
    }
    else
        return false;
}
nsresult
imgFrame::InitWithDrawable(gfxDrawable* aDrawable,
                           const nsIntSize& aSize,
                           const SurfaceFormat aFormat,
                           GraphicsFilter aFilter,
                           uint32_t aImageFlags)
{
  // Assert for properties that should be verified by decoders,
  // warn for properties related to bad content.
  if (!AllowedImageSize(aSize.width, aSize.height)) {
    NS_WARNING("Should have legal image size");
    mAborted = true;
    return NS_ERROR_FAILURE;
  }

  mImageSize = aSize;
  mOffset.MoveTo(0, 0);
  mSize.SizeTo(aSize.width, aSize.height);

  mFormat = aFormat;
  mPaletteDepth = 0;

  RefPtr<DrawTarget> target;

  bool canUseDataSurface =
    gfxPlatform::GetPlatform()->CanRenderContentToDataSurface();

  if (canUseDataSurface) {
    // It's safe to use data surfaces for content on this platform, so we can
    // get away with using volatile buffers.
    MOZ_ASSERT(!mImageSurface, "Called imgFrame::InitWithDrawable() twice?");

    mVBuf = AllocateBufferForImage(mSize, mFormat);
    if (!mVBuf) {
      mAborted = true;
      return NS_ERROR_OUT_OF_MEMORY;
    }

    int32_t stride = VolatileSurfaceStride(mSize, mFormat);
    VolatileBufferPtr<uint8_t> ptr(mVBuf);
    if (!ptr) {
      mAborted = true;
      return NS_ERROR_OUT_OF_MEMORY;
    }
    if (mVBuf->OnHeap()) {
      memset(ptr, 0, stride * mSize.height);
    }
    mImageSurface = CreateLockedSurface(mVBuf, mSize, mFormat);

    target = gfxPlatform::GetPlatform()->
      CreateDrawTargetForData(ptr, mSize, stride, mFormat);
  } else {
    // We can't use data surfaces for content, so we'll create an offscreen
    // surface instead.  This means if someone later calls RawAccessRef(), we
    // may have to do an expensive readback, but we warned callers about that in
    // the documentation for this method.
    MOZ_ASSERT(!mOptSurface, "Called imgFrame::InitWithDrawable() twice?");

    target = gfxPlatform::GetPlatform()->
        CreateOffscreenContentDrawTarget(mSize, mFormat);
  }

  if (!target) {
    mAborted = true;
    return NS_ERROR_OUT_OF_MEMORY;
  }

  // Draw using the drawable the caller provided.
  nsIntRect imageRect(0, 0, mSize.width, mSize.height);
  nsRefPtr<gfxContext> ctx = new gfxContext(target);
  gfxUtils::DrawPixelSnapped(ctx, aDrawable, mSize,
                             ImageRegion::Create(imageRect),
                             mFormat, aFilter, aImageFlags);

  if (canUseDataSurface && !mImageSurface) {
    NS_WARNING("Failed to create VolatileDataSourceSurface");
    mAborted = true;
    return NS_ERROR_OUT_OF_MEMORY;
  }

  if (!canUseDataSurface) {
    // We used an offscreen surface, which is an "optimized" surface from
    // imgFrame's perspective.
    mOptSurface = target->Snapshot();
  }

  // If we reach this point, we should regard ourselves as complete.
  mDecoded = GetRect();
  MOZ_ASSERT(IsImageComplete());

  return NS_OK;
}
void KisTransformMaskTest::testWeirdFullUpdates()
{
    //TestUtil::ExternalImageChecker chk("mask_with_offset", "transform_mask_updates");

    QRect imageRect(0,0,512,512);
    QRect fillRect(10, 10, 236, 236);
    TestUtil::MaskParent p(imageRect);

    p.layer->paintDevice()->fill(fillRect, KoColor(Qt::red, p.layer->colorSpace()));

    KisPaintLayerSP player1 = new KisPaintLayer(p.image, "pl1", OPACITY_OPAQUE_U8, p.image->colorSpace());
    player1->paintDevice()->fill(fillRect, KoColor(Qt::red, p.layer->colorSpace()));
    p.image->addNode(player1, p.image->root());

    KisTransformMaskSP mask1 = new KisTransformMask();
    mask1->setName("mask1");
    QTransform transform1 =
        QTransform::fromTranslate(256, 0);
    mask1->setTransformParams(KisTransformMaskParamsInterfaceSP(
                                  new KisDumbTransformMaskParams(transform1)));

    p.image->addNode(mask1, player1);


    KisPaintLayerSP player2 = new KisPaintLayer(p.image, "pl2", OPACITY_OPAQUE_U8, p.image->colorSpace());
    player2->paintDevice()->fill(fillRect, KoColor(Qt::red, p.layer->colorSpace()));
    p.image->addNode(player2, p.image->root());

    KisTransformMaskSP mask2 = new KisTransformMask();
    mask2->setName("mask2");
    QTransform transform2 =
        QTransform::fromTranslate(0, 256);
    mask2->setTransformParams(KisTransformMaskParamsInterfaceSP(
                                  new KisDumbTransformMaskParams(transform2)));

    p.image->addNode(mask2, player2);


    KisPaintLayerSP player3 = new KisPaintLayer(p.image, "pl3", OPACITY_OPAQUE_U8, p.image->colorSpace());
    player3->paintDevice()->fill(fillRect, KoColor(Qt::red, p.layer->colorSpace()));
    p.image->addNode(player3, p.image->root());

    KisTransformMaskSP mask3 = new KisTransformMask();
    mask3->setName("mask3");
    QTransform transform3 =
        QTransform::fromTranslate(256, 256);
    mask3->setTransformParams(KisTransformMaskParamsInterfaceSP(
                                  new KisDumbTransformMaskParams(transform3)));

    p.image->addNode(mask3, player3);



    //p.image->initialRefreshGraph();

    p.image->refreshGraphAsync(0, QRect(0,0,256,256), QRect());
    p.image->waitForDone();

    QVERIFY(player1->projection()->extent().isEmpty());
    QVERIFY(player1->projection()->exactBounds().isEmpty());

    QVERIFY(player2->projection()->extent().isEmpty());
    QVERIFY(player2->projection()->exactBounds().isEmpty());

    QVERIFY(player3->projection()->extent().isEmpty());
    QVERIFY(player3->projection()->exactBounds().isEmpty());

    QCOMPARE(p.image->projection()->exactBounds(), QRect(QRect(10,10,236,236)));



    p.image->refreshGraphAsync(0, QRect(0,256,256,256), QRect());
    p.image->waitForDone();

    QVERIFY(player1->projection()->extent().isEmpty());
    QVERIFY(player1->projection()->exactBounds().isEmpty());

    QVERIFY(!player2->projection()->extent().isEmpty());
    QVERIFY(!player2->projection()->exactBounds().isEmpty());

    QVERIFY(player3->projection()->extent().isEmpty());
    QVERIFY(player3->projection()->exactBounds().isEmpty());

    QCOMPARE(p.image->projection()->exactBounds(), QRect(QRect(10,10,236,492)));


    p.image->refreshGraphAsync(0, QRect(256,0,256,256), QRect());
    p.image->waitForDone();

    QVERIFY(!player1->projection()->extent().isEmpty());
    QVERIFY(!player1->projection()->exactBounds().isEmpty());

    QVERIFY(!player2->projection()->extent().isEmpty());
    QVERIFY(!player2->projection()->exactBounds().isEmpty());

    QVERIFY(player3->projection()->extent().isEmpty());
    QVERIFY(player3->projection()->exactBounds().isEmpty());

    QCOMPARE(p.image->projection()->exactBounds(), QRect(QRect(10,10,492,492)));
    QVERIFY((p.image->projection()->region() & QRect(256,256,256,256)).isEmpty());



    p.image->refreshGraphAsync(0, QRect(256,256,256,256), QRect());
    p.image->waitForDone();

    QVERIFY(!player1->projection()->extent().isEmpty());
    QVERIFY(!player1->projection()->exactBounds().isEmpty());

    QVERIFY(!player2->projection()->extent().isEmpty());
    QVERIFY(!player2->projection()->exactBounds().isEmpty());

    QVERIFY(!player3->projection()->extent().isEmpty());
    QVERIFY(!player3->projection()->exactBounds().isEmpty());

    QCOMPARE(p.image->projection()->exactBounds(), QRect(QRect(10,10,492,492)));
    QVERIFY(!(p.image->projection()->region() & QRect(256,256,256,256)).isEmpty());

    p.image->waitForDone();

    KIS_DUMP_DEVICE_2(p.image->projection(), imageRect, "image_proj", "dd");

}
std::size_t DefaultBitImageCommands::printImage(const ofPixels_<unsigned char>& pixels,
                                                ofAlignHorz alignHorz,
                                                float ditherThreshold,
                                                float ditherQuantWeight,
                                                BaseCodes::PrintResolution printResolution,
                                                int printHeadWidth,
                                                int printHeadHeight)
{

    int numVerticalDots = 0;
    int maxHorizontalDots = 0;
    int verticalScale = 1;

    switch(printResolution)
    {
        case BaseCodes::RESOLUTION_8_DOTS_SINGLE_DENSITY:
            maxHorizontalDots = printHeadWidth / 2;
            numVerticalDots = 8;
            break;
        case BaseCodes::RESOLUTION_8_DOTS_DOUBLE_DENSITY:
            maxHorizontalDots = printHeadWidth;
            numVerticalDots = 8;
            break;
        case BaseCodes::RESOLUTION_24_DOTS_SINGLE_DENSITY:
            maxHorizontalDots = printHeadWidth / 2;
            numVerticalDots = 24;
            break;
        case BaseCodes::RESOLUTION_24_DOTS_DOUBLE_DENSITY:
            maxHorizontalDots = printHeadWidth;
            numVerticalDots = 24;
            break;
    }

    std::size_t totalBytesWritten = 0;

    ofRectangle imageRect(0,0,pixels.getWidth(),pixels.getHeight());
    ofRectangle rectangle(0,0,maxHorizontalDots,pixels.getHeight());

    imageRect.scaleTo(rectangle,
                      OF_ASPECT_RATIO_KEEP,
                      alignHorz,
                      OF_ALIGN_VERT_TOP,
                      alignHorz,
                      OF_ALIGN_VERT_TOP);

    int width = rectangle.getWidth();
    int height = imageRect.getHeight();

    // ensure vertical res
    if(height != numVerticalDots)
    {
        int remainder = height % numVerticalDots;
        if (remainder != 0)
        {
            height = height + numVerticalDots - remainder;
        }
    }

    ofPixels pix = pixels; // get a copy
    ofPixels toPrint;

    toPrint.allocate(width, height, pix.getNumChannels());
    toPrint.setColor(ofColor(255));

    pix.resize(imageRect.getWidth(), imageRect.getHeight());
    pix.pasteInto(toPrint,imageRect.getX(),imageRect.getY());

    toPrint = ImageUtils::dither(toPrint,ditherThreshold,ditherQuantWeight);


    cout << pix.getWidth() << " / " << pix.getHeight() << endl;

    ofPixels bandBuffer;

    bandBuffer.allocate(toPrint.getWidth(), numVerticalDots, toPrint.getNumChannels());

    // go into page mode
    totalBytesWritten += writeByte(BaseCodes::ESC);
    totalBytesWritten += writeByte('L');

    // set the print area / origin
    totalBytesWritten += setPageModePrintArea(0,0,toPrint.getWidth(),toPrint.getHeight() * 2); // TODO 2 * works for double vert density


    for(int y = 0; y < height; y += numVerticalDots)
    {
        // set the vertical displacement
        const uint8_t command[3] = { BaseCodes::ESC, '3', numVerticalDots * 2 }; // TODO 2 * works for double vert density
        totalBytesWritten += writeBytes(command, 3);

        bandBuffer.clear();
        toPrint.cropTo(bandBuffer,0,y,width,numVerticalDots);
        totalBytesWritten += selectBitImageMode(bandBuffer, printResolution);
        totalBytesWritten += writeByte(BaseCodes::LF); // feed a line

        // set vertical displacement back to normal
        const uint8_t command0[2] = { BaseCodes::ESC, '2' };
        totalBytesWritten += writeBytes(command0, 2);
    }


//    totalBytesWritten += writeByte(BaseCodes::LF); // feed a line
    totalBytesWritten += writeByte(BaseCodes::FF);

    return totalBytesWritten;
}
void KisSimpleUpdateQueueTest::testJobProcessing()
{
    KisTestableUpdaterContext context(2);

    QRect imageRect(0,0,200,200);

    const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
    KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "merge test");

    KisPaintLayerSP paintLayer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8);

    image->lock();
    image->addNode(paintLayer);
    image->unlock();

    QRect dirtyRect1(0,0,50,100);
    QRect dirtyRect2(0,0,100,100);
    QRect dirtyRect3(50,0,50,100);
    QRect dirtyRect4(150,150,50,50);

    QVector<KisUpdateJobItem*> jobs;
    KisWalkersList walkersList;

    /**
     * Process the queue and look what has been added into
     * the updater context
     */

    KisTestableSimpleUpdateQueue queue;

    queue.addJob(paintLayer, dirtyRect1, imageRect);
    queue.addJob(paintLayer, dirtyRect2, imageRect);
    queue.addJob(paintLayer, dirtyRect3, imageRect);
    queue.addJob(paintLayer, dirtyRect4, imageRect);

    queue.processQueue(context);

    jobs = context.getJobs();

    QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect2));
    QVERIFY(checkWalker(jobs[1]->walker(), dirtyRect4));
    QCOMPARE(jobs.size(), 2);

    walkersList = queue.getWalkersList();

    QCOMPARE(walkersList.size(), 0);


    /**
     * Test blocking the process
     */

    context.clear();

    queue.blockProcessing(context);

    queue.addJob(paintLayer, dirtyRect1, imageRect);
    queue.addJob(paintLayer, dirtyRect2, imageRect);
    queue.addJob(paintLayer, dirtyRect3, imageRect);
    queue.addJob(paintLayer, dirtyRect4, imageRect);

    jobs = context.getJobs();
    QCOMPARE(jobs[0]->walker(), KisBaseRectsWalkerSP(0));
    QCOMPARE(jobs[1]->walker(), KisBaseRectsWalkerSP(0));

    queue.startProcessing(context);

    jobs = context.getJobs();

    QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect2));
    QVERIFY(checkWalker(jobs[1]->walker(), dirtyRect4));
}
Exemple #6
0
/// Draw the item
bool InstanceVisual::Draw(wxDC& dc, InstanceCtrl* ctrl, const wxRect& rect, int style)
{
	wxColour backgroundColor = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
	wxColour textColor = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
	wxColour highlightTextColor = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
	wxColour focus_color = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
	wxColour focussedSelection = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
	
	wxRect imageRect(rect.x + (rect.width - 32) / 2, rect.y, 32, 32);
	
	if (style & wxINST_SELECTED)
	{
		wxBrush brush(focus_color);
		wxPen pen(focus_color);
		dc.SetBrush(brush);
		dc.SetPen(pen);
	}
	else
	{
		wxBrush brush(backgroundColor);
		wxPen pen(backgroundColor);
		dc.SetBrush(brush);
		dc.SetPen(pen);
	}
	
	// Draw the label
	wxString name = m_inst->GetName();
	if (!name.IsEmpty())
	{
		int margin = ctrl->GetItemMargin();
		
		wxRect textRect;
		textRect.x = rect.x + margin;
		textRect.y = rect.y + imageRect.height + 2 * margin;
		textRect.width = rect.width - 2 * margin;
		
		dc.SetFont(ctrl->GetFont());
		if (style & wxINST_SELECTED)
			dc.SetTextForeground(highlightTextColor);
		else
			dc.SetTextForeground(textColor);
		dc.SetBackgroundMode(wxTRANSPARENT);
		
		int yoffset = 0;
		wxSize textsize = dc.GetMultiLineTextExtent(name_wrapped);
		textRect.height = textsize.GetHeight();
		if (style & wxINST_SELECTED)
		{
			wxRect hiRect;
			hiRect.x = rect.x + (rect.width - textsize.x) / 2 - margin;
			hiRect.y = textRect.y - margin;
			hiRect.SetSize(textsize + wxSize(2 * margin, 2 * margin));
			dc.DrawRectangle(hiRect);
		}
		dc.DrawLabel(name_wrapped, textRect, wxALIGN_TOP | wxALIGN_CENTER_HORIZONTAL);
	}
	
	// Draw the icon
	auto list = InstIconList::Instance();
	wxImage icon;
	if (style & wxINST_SELECTED)
		icon = list->getHLImageForKey(m_inst->GetIconKey());
	else
		icon = list->getImageForKey(m_inst->GetIconKey());
	wxBitmap bmap = wxBitmap(icon);
	int x = imageRect.x + (imageRect.width - bmap.GetWidth()) / 2;
	int y = imageRect.y + (imageRect.height - bmap.GetHeight()) / 2;
	dc.DrawBitmap(bmap , x, y, true);
	
	return true;
}
void FlatButton::DrawItem(LPDRAWITEMSTRUCT dis)
{
  CDC* dcPaint = CDC::FromHandle(dis->hDC);
  CRect rectPaint(dis->rcItem);
  bool disabled = (dis->itemState & ODS_DISABLED) != 0;

  // Create a bitmap to paint into
  CDC dc;
  dc.CreateCompatibleDC(dcPaint);
  CRect rect(0,0,rectPaint.Width(),rectPaint.Height());
  CDibSection bitmap;
  if (bitmap.CreateBitmap(dc.GetSafeHdc(),rect.Width(),rect.Height()) == FALSE)
    return;
  CBitmap* oldBitmap = CDibSection::SelectDibSection(dc,&bitmap);

  // Draw the background
  if (dis->itemState & ODS_SELECTED)
  {
    // Get the bitmap to indicate a selected button
    CBitmap selectBitmap;
    selectBitmap.LoadBitmap(IDR_FLAT_SELECT);
    CDC selectDC;
    selectDC.CreateCompatibleDC(&dc);
    CBitmap* oldBitmap = selectDC.SelectObject(&selectBitmap);

    // Get the bitmap's dimensions
    BITMAP bitmapInfo;
    selectBitmap.GetBitmap(&bitmapInfo);

    // Stretch the bitmap into the selected item's background
    dc.StretchBlt(0,0,rect.Width(),rect.Height(),
      &selectDC,0,0,bitmapInfo.bmWidth,bitmapInfo.bmHeight,SRCCOPY);
    selectDC.SelectObject(oldBitmap);
  }
  else
    dc.FillSolidRect(rect,::GetSysColor(COLOR_BTNFACE));

  // Get the button's text
  CString text;
  GetWindowText(text);

  // Draw the contents of the button
  if (text == "?<")
  {
    CRect imageRect(rect);
    if (imageRect.Width() > imageRect.Height())
      imageRect.DeflateRect((imageRect.Width() - imageRect.Height())/2,0);
    int gap = imageRect.Height()/6;
    imageRect.DeflateRect(gap,gap);
    CDibSection* dib = GetImage("Arrow-left",imageRect.Size(),disabled);
    bitmap.AlphaBlend(dib,gap,gap,FALSE);
  }
  else if (text == "?>")
  {
    CRect imageRect(rect);
    if (imageRect.Width() > imageRect.Height())
      imageRect.DeflateRect((imageRect.Width() - imageRect.Height())/2,0);
    int gap = imageRect.Height()/6;
    imageRect.DeflateRect(gap,gap);
    CDibSection* dib = GetImage("Arrow-right",imageRect.Size(),disabled);
    bitmap.AlphaBlend(dib,gap,gap,FALSE);
  }

  // Draw the separator
  CPen shadowPen(PS_SOLID,0,::GetSysColor(COLOR_BTNSHADOW));
  dc.SelectObject(shadowPen);
  int gap = rect.Height()/6;
  dc.MoveTo(rect.right-1,gap);
  dc.LineTo(rect.right-1,rect.bottom-gap);

  // Draw the control from the bitmap
  dcPaint->BitBlt(rectPaint.left,rectPaint.top,rectPaint.Width(),rectPaint.Height(),&dc,0,0,SRCCOPY);
  dc.SelectObject(oldBitmap);
}
Exemple #8
0
void GAoiSelector::on_FullFrameButton_clicked()
{
	QRectF imageRect(QPoint(0, 0), m_KnownFullImageSize);
	InitAoiSelectorItems(imageRect);
}
bool ossimH5GridModel::setGridNodes( H5::DataSet* latDataSet,
                                     H5::DataSet* lonDataSet,
                                     const ossimIrect& validRect )
{
   bool status = false;

   if ( latDataSet && lonDataSet )
   {
      m_crossesDateline = ossim_hdf5::crossesDateline( *lonDataSet, validRect );
      
      if ( m_crossesDateline )
      {
         theLonGrid.setDomainType(ossimDblGrid::WRAP_360);
      }
      else
      {
         theLonGrid.setDomainType(ossimDblGrid::WRAP_180);
      }

      // Get dataspace of the dataset.
      H5::DataSpace latDataSpace = latDataSet->getSpace();
      H5::DataSpace lonDataSpace = lonDataSet->getSpace();
      const ossim_int32 LAT_DIM_COUNT = latDataSpace.getSimpleExtentNdims();
      const ossim_int32 LON_DIM_COUNT = lonDataSpace.getSimpleExtentNdims();
      
      // Number of dimensions of the input dataspace:
      if ( ( LAT_DIM_COUNT == 2 ) && ( LON_DIM_COUNT == 2 ) )
      {
         const ossim_uint32 ROWS = validRect.height();
         const ossim_uint32 COLS = validRect.width();
         const ossim_uint32 GRID_SIZE = 4; // Only grab every 4th value.

         //---
         // Get the extents:
         // dimsOut[0] is height, dimsOut[1] is width:
         //---
         std::vector<hsize_t> latDimsOut(LAT_DIM_COUNT);
         latDataSpace.getSimpleExtentDims( &latDimsOut.front(), 0 );
         std::vector<hsize_t> lonDimsOut(LON_DIM_COUNT);
         lonDataSpace.getSimpleExtentDims( &lonDimsOut.front(), 0 );
         
         // Verify valid rect within our bounds:
         if ( (ROWS <= latDimsOut[0] ) && (ROWS <= lonDimsOut[0] ) &&
              (COLS <= latDimsOut[1] ) && (COLS <= lonDimsOut[1] ) )
         {
            //----
            // Initialize the ossimDblGrids:
            //---
            ossimDpt dspacing (GRID_SIZE, GRID_SIZE);
            
            ossim_uint32 gridRows = ROWS / GRID_SIZE + 1;
            ossim_uint32 gridCols = COLS / GRID_SIZE + 1;
            
            // Round up if size doesn't fall on end pixel.
            if ( ROWS % GRID_SIZE) ++gridRows;
            if ( COLS % GRID_SIZE) ++gridCols;

            ossimIpt gridSize (gridCols, gridRows);
            
            // The grid as used in base class, has UV-space always at 0,0 origin            
            ossimDpt gridOrigin(0.0,0.0);

            const ossim_float64 NULL_VALUE = -999.0;
            
            theLatGrid.setNullValue(ossim::nan());
            theLonGrid.setNullValue(ossim::nan());
            theLatGrid.initialize(gridSize, gridOrigin, dspacing);
            theLonGrid.initialize(gridSize, gridOrigin, dspacing);            
            
            std::vector<hsize_t> inputCount(LAT_DIM_COUNT);
            std::vector<hsize_t> inputOffset(LAT_DIM_COUNT);
            
            inputOffset[0] = 0; // row is set below.
            inputOffset[1] = validRect.ul().x; // col
            
            inputCount[0] = 1; // row
            inputCount[1] = (hsize_t)COLS; // col
            
            // Output dataspace dimensions. Reading a line at a time.
            const ossim_int32 OUT_DIM_COUNT = 3;
            std::vector<hsize_t> outputCount(OUT_DIM_COUNT);
            outputCount[0] = 1;    // band
            outputCount[1] = 1;    // row
            outputCount[2] = COLS; // col
            
            // Output dataspace offset.
            std::vector<hsize_t> outputOffset(OUT_DIM_COUNT);
            outputOffset[0] = 0;
            outputOffset[1] = 0;
            outputOffset[2] = 0;
            
            ossimScalarType scalar = ossim_hdf5::getScalarType( latDataSet );
            if ( scalar == OSSIM_FLOAT32 )
            {
               // Set the return status to true if we get here...
               status = true;
               
               // See if we need to swap bytes:
               ossimEndian* endian = 0;
               if ( ( ossim::byteOrder() != ossim_hdf5::getByteOrder( latDataSet ) ) )
               {
                  endian = new ossimEndian();
               }
               
               // Native type:
               H5::DataType latDataType = latDataSet->getDataType();
               H5::DataType lonDataType = lonDataSet->getDataType();

               // Output dataspace always the same, width of one line.
               H5::DataSpace bufferDataSpace( OUT_DIM_COUNT, &outputCount.front());
               bufferDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                &outputCount.front(),
                                                &outputOffset.front() );

               //  Arrays to hold a single line of latitude longitude values.
               vector<ossim_float32> latValue(COLS);
               vector<ossim_float32> lonValue(COLS);
               hsize_t row = 0;

               // Line loop:
               for ( ossim_uint32 y = 0; y < gridRows; ++y )
               {
                  // row = line in image space
                  row = y*GRID_SIZE;

                  if ( row < ROWS )
                  {
                     inputOffset[0] = row + validRect.ul().y;

                     latDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                   &inputCount.front(),
                                                   &inputOffset.front() );
                     lonDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                   &inputCount.front(),
                                                   &inputOffset.front() );
                  
                     // Read data from file into the buffer.
                     latDataSet->read( &(latValue.front()), latDataType,
                                       bufferDataSpace, latDataSpace );
                     lonDataSet->read( &(lonValue.front()), lonDataType,
                                       bufferDataSpace, lonDataSpace );
                  
                     if ( endian )
                     {
                        // If the endian pointer is initialized(not zero) swap the bytes.
                        endian->swap( &(latValue.front()), COLS );
                        endian->swap( &(lonValue.front()), COLS );  
                     }
                  
                     // Sample loop:
                     hsize_t col = 0;
                     
                     for ( ossim_uint32 x = 0; x < gridCols; ++x )
                     {
                        ossim_float32 lat = ossim::nan();
                        ossim_float32 lon = ossim::nan();
                        
                        // col = sample in image space
                        col = x*GRID_SIZE;

                        if ( col < COLS )
                        {
                           if ( (latValue[col] > NULL_VALUE)&&(lonValue[col] > NULL_VALUE) )
                           {
                              lat = latValue[col];
                              lon = lonValue[col];
                              if ( m_crossesDateline )
                              {
                                 if ( lon < 0.0 ) lon += 360;
                              }
                           }
                           else // Nulls in grid!
                           {
                              std::string errMsg =
                                 "ossimH5GridModel::setGridNodes encountered nans!";
                              throw ossimException(errMsg); 
                           }
                        }
                        else // Last column is outside of image bounds.
                        {
                           // Get the last two latitude values:
                           ossim_float32 lat1 = theLatGrid.getNode( x-2, y );
                           ossim_float32 lat2 = theLatGrid.getNode( x-1, y );

                           // Get the last two longitude values
                           ossim_float32 lon1 = theLonGrid.getNode( x-2, y );
                           ossim_float32 lon2 = theLonGrid.getNode( x-1, y );
                           
                           if ( ( lat1 > NULL_VALUE ) && ( lat2 > NULL_VALUE ) )
                           {
                              // Delta between last two latitude grid values.
                              ossim_float32 latSpacing = lat2 - lat1;
                           
                              // Compute:
                              lat = lat2 + latSpacing;
                           }
                           else // Nulls in grid!
                           {
                              std::string errMsg =
                                 "ossimH5GridModel::setGridNodes encountered nans!";
                              throw ossimException(errMsg);
                           }

                           if ( ( lon1 > NULL_VALUE ) && ( lon2 > NULL_VALUE ) )
                           {
                              // Delta between last two longitude values.
                              ossim_float32 lonSpacing = lon2 - lon1;
                           
                              // Compute:
                              lon = lon2 + lonSpacing;

                              // Check for wrap:
                              if ( !m_crossesDateline && ( lon > 180 ) )
                              {
                                 lon -= 360.0;
                              }
                           }
                           else // Nulls in grid!
                           {
                              std::string errMsg =
                                 "ossimH5GridModel::setGridNodes encountered nans!";
                              throw ossimException(errMsg);
                           }

#if 0 /* Please leave for debug. (drb) */                        
                           cout << "lat1: " << lat1 << " lat2 " << lat2
                                << " lon1 " << lon1  << " lon2 " << lon2
                                << "\n";
#endif
                        }
                        
                        // Assign the latitude and longitude.
                        theLatGrid.setNode( x, y, lat );
                        theLonGrid.setNode( x, y, lon );
                        
#if 0 /* Please leave for debug. (drb) */ 
                        cout << "x,y,col,row,lat,lon:" << x << "," << y << ","
                             << col << "," << row << ","
                             << theLatGrid.getNode(x, y)
                             << "," << theLonGrid.getNode( x, y) << "\n";
#endif
                        
                     } // End sample loop.
                     
                  }
                  else // Row is outside of image bounds:
                  {
                     // Sample loop:
                     for ( ossim_uint32 x = 0; x < gridCols; ++x )
                     {
                        ossim_float32 lat        = ossim::nan();
                        ossim_float32 lon        = ossim::nan();
                        
                        ossim_float32 lat1 = theLatGrid.getNode( x, y-2 );
                        ossim_float32 lat2 = theLatGrid.getNode( x, y-1 );
                        ossim_float32 lon1 = theLonGrid.getNode( x, y-2 );
                        ossim_float32 lon2 = theLonGrid.getNode( x, y-1 );
                        
                        if ( ( lon1 > NULL_VALUE ) && ( lon2 > NULL_VALUE ) )
                        {
                           // Delta between last two longitude values.
                           ossim_float32 lonSpacing = lon2 - lon1;
                           
                           // Compute:
                           lon = lon2 + lonSpacing;
                           
                           // Check for wrap:
                           if ( !m_crossesDateline && ( lon > 180 ) )
                           {
                              lon -= 360.0;
                           }
                        }
                        else // Nulls in grid!
                        {
                           std::string errMsg =
                              "ossimH5GridModel::setGridNodes encountered nans!";
                           throw ossimException(errMsg);
                        }
                        
                        if ( ( lat1 > NULL_VALUE ) && ( lat2 > NULL_VALUE ) )
                        {
                           // Delta between last two latitude values.
                           ossim_float32 latSpacing = lat2 - lat1;

                           lat = lat2 + latSpacing;
                        }
                        else // Nulls in grid!
                        {
                           std::string errMsg =
                              "ossimH5GridModel::setGridNodes encountered nans!";
                           throw ossimException(errMsg);
                        }
                        
#if 0 /* Please leave for debug. (drb) */
                        hsize_t col = x*GRID_SIZE; // Sample in image space
                        cout << "lat1: " << lat1 << " lat2 " << lat2
                             << " lon1 " << lon1  << " lon2 " << lon2
                             << "\nx,y,col,row,lat,lon:" << x << "," << y << ","
                             << col << "," << row << "," << lat << "," << lon << "\n";
#endif
                        // Assign the latitude::
                        theLatGrid.setNode( x, y, lat );

                        // Assign the longitude.
                        theLonGrid.setNode( x, y, lon );
                     
                     } // End sample loop.
                  
                  } // Matches if ( row < imageRows ){...}else{
                  
               } // End line loop.

               latDataSpace.close();
               lonDataSpace.close();

               if ( status )
               {
                  theSeedFunction = ossim_hdf5::getBilinearProjection(
                     *latDataSet,*lonDataSet, validRect );
                  
                  // Bileaner projection to handle
                  ossimDrect imageRect(validRect);
                  initializeModelParams(imageRect);

                  // debugDump();
               }

               if ( endian )
               {
                  delete endian;
                  endian = 0;
               }
               
            } // Matches: if ( scalar == OSSIM_FLOAT32 )
            
         } // Matches: if ( (latDimsOut[0] == imageRows) ...
         
      } // Matches: if ( ( LAT_DIM_COUNT == 2 ) ...

   } // Matches: if ( latDataSet && lonDataSet

   return status;
   
} // End: bool ossimH5GridModel::setGridNodes( H5::DataSet* latDataSet, ... )
Exemple #10
0
void QgsMapCanvas::mapUpdateTimeout()
{
  const QImage& img = mJob->renderedImage();
  mMap->setContent( img, imageRect( img, mJob->mapSettings() ) );
}
Exemple #11
0
void FileView::paint(QPainter* painter, const QRect& rect, const QPalette& palette, DisplayMode displayMode) const {
	painter->save();
	painter->setRenderHint(QPainter::Antialiasing, true);

	painter->translate(rect.x(), rect.y());

	if(displayMode == DM_Selected)
		painter->setBrush(palette.highlightedText());
	else
		painter->setBrush(palette.foreground());

	painter->setPen(QPen(painter->brush(), 1));
	
	int textFlags = Qt::AlignLeft | Qt::AlignVCenter;

	QFont font(painter->font());
	font.setBold(true);
	painter->setFont(font);

	QString nameDisplay = (mode == TM_Send) ? tr("To: ") : tr("From: ");
	nameDisplay.append(userName);
	QRect textRect = QRect(54, 0, rect.width() - 58, 18);
	QString text = painter->fontMetrics().elidedText(nameDisplay, Qt::ElideRight, textRect.width());
	painter->drawText(textRect, textFlags, text);
	
	font.setBold(false);
	painter->setFont(font);
	textRect = QRect(54, 18, rect.width() - 58, 18);
	text = painter->fontMetrics().elidedText(fileDisplay, Qt::ElideMiddle, textRect.width());
	painter->drawText(textRect, textFlags, text);

	bool drawProgress = false;
	QString stateDisplay;
	switch(state) {
	case TS_Send:
		stateDisplay = timeDisplay + " left - " + posDisplay + " of " + sizeDisplay + " (" + speedDisplay + ")";
		drawProgress = true;
		break;
	case TS_Receive:
		stateDisplay = timeDisplay + " left - " + posDisplay + " of " + sizeDisplay + " (" + speedDisplay + ")";
		drawProgress = true;
		break;
	case TS_Complete:
		stateDisplay = tr("Completed");
		break;
	case TS_Cancel:
		stateDisplay = tr("Canceled");
		break;
	case TS_Abort:
		stateDisplay = tr("Interrupted");
		break;
    default:
        break;
	}
	textRect = QRect(54, 36, rect.width() - 58, 18);
	text = painter->fontMetrics().elidedText(stateDisplay, Qt::ElideRight, textRect.width());
	painter->drawText(textRect, textFlags, text);

	if(drawProgress) {
		int spanAngle = ((double)position / (double)fileSize) * 360;

		painter->setBrush(QBrush(QColor(230, 230, 230)));
		painter->setPen(QPen(QColor(230, 230, 230)));
		painter->drawPie(4, 4, 46, 46, (90 - spanAngle) * 16, -(360 - spanAngle) * 16);

		painter->setBrush(QBrush(QColor(150, 225, 110)));
		painter->setPen(QPen(QColor(150, 225, 110)));
		painter->drawPie(4, 4, 46, 46, 90 * 16, -spanAngle * 16);

		painter->setBrush(QBrush(QColor(255, 255, 255)));
		painter->setPen(QPen(QColor(255, 255, 255), 2));
		painter->drawLine(27, 5, 27, 49);
		painter->drawLine(5, 27, 49, 27);
		painter->drawLine(11, 11, 42, 42);
		painter->drawLine(42, 11, 11, 42);
	}

	QRect imageRect(11, 11, 32, 32);
	painter->drawPixmap(imageRect, icon);

	painter->restore();
}
Exemple #12
0
bool ossimHdfGridModel::setGridNodes( H5::DataSet* latDataSet,
                                      H5::DataSet* lonDataSet,
                                      ossim_uint32 imageRows,
                                      ossim_uint32 imageCols )
{
    bool status = false;

    if ( latDataSet && lonDataSet )
    {
        const ossim_uint32 GRID_SIZE = 32; // Only grab every 32nd value.

        // Get dataspace of the dataset.
        H5::DataSpace latDataSpace = latDataSet->getSpace();
        H5::DataSpace lonDataSpace = lonDataSet->getSpace();
        const ossim_int32 LAT_DIM_COUNT = latDataSpace.getSimpleExtentNdims();
        const ossim_int32 LON_DIM_COUNT = latDataSpace.getSimpleExtentNdims();

        // Number of dimensions of the input dataspace:
        if ( ( LAT_DIM_COUNT == 2 ) && ( LON_DIM_COUNT == 2 ) )
        {
            //---
            // Get the extents:
            // dimsOut[0] is height, dimsOut[1] is width:         //---
            std::vector<hsize_t> latDimsOut(LAT_DIM_COUNT);
            latDataSpace.getSimpleExtentDims( &latDimsOut.front(), 0 );
            std::vector<hsize_t> lonDimsOut(LON_DIM_COUNT);
            lonDataSpace.getSimpleExtentDims( &lonDimsOut.front(), 0 );

            // Verify same as image:
            if ( (latDimsOut[0] == imageRows) &&
                    (lonDimsOut[0] == imageRows) &&
                    (latDimsOut[1] == imageCols) &&
                    (lonDimsOut[1] == imageCols) )
            {
                //---
                // Capture the rectangle:
                // dimsOut[0] is height, dimsOut[1] is width:
                //---
                ossimIrect rect = ossimIrect( 0, 0,
                                              static_cast<ossim_int32>( latDimsOut[1]-1 ),
                                              static_cast<ossim_int32>( latDimsOut[0]-1 ) );

                //----
                // Initialize the ossimDblGrids:
                //---
                ossimDpt dspacing (GRID_SIZE, GRID_SIZE);

                ossim_uint32 gridRows = imageRows / GRID_SIZE + 1;
                ossim_uint32 gridCols = imageCols / GRID_SIZE + 1;

                // Round up if size doesn't fall on end pixel.
                if ( imageRows % GRID_SIZE) ++gridRows;
                if ( imageCols % GRID_SIZE) ++gridCols;

                ossimIpt gridSize (gridCols, gridRows);

                // The grid as used in base class, has UV-space always at 0,0 origin
                ossimDpt gridOrigin(0.0,0.0);

                const ossim_float64 NULL_VALUE = -999.0;
                theLatGrid.setNullValue(ossim::nan());
                theLonGrid.setNullValue(ossim::nan());
                theLatGrid.initialize(gridSize, gridOrigin, dspacing);
                theLonGrid.initialize(gridSize, gridOrigin, dspacing);

                std::vector<hsize_t> inputCount(LAT_DIM_COUNT);
                std::vector<hsize_t> inputOffset(LAT_DIM_COUNT);

                inputOffset[0] = 0; // row
                inputOffset[1] = 0; // col

                inputCount[0] = 1; // row
                inputCount[1] = (hsize_t)imageCols; // col

                // Output dataspace dimensions. Reading a line at a time.
                const ossim_int32 OUT_DIM_COUNT = 3;
                std::vector<hsize_t> outputCount(OUT_DIM_COUNT);
                outputCount[0] = 1; // band
                outputCount[1] = 1; // row
                outputCount[2] = imageCols; // col

                // Output dataspace offset.
                std::vector<hsize_t> outputOffset(OUT_DIM_COUNT);
                outputOffset[0] = 0;
                outputOffset[1] = 0;
                outputOffset[2] = 0;

                ossimScalarType scalar = ossim_hdf5::getScalarType( latDataSet );
                if ( scalar == OSSIM_FLOAT32 )
                {
                    // Set the return status to true if we get here...
                    status = true;

                    // See if we need to swap bytes:
                    ossimEndian* endian = 0;
                    if ( ( ossim::byteOrder() != ossim_hdf5::getByteOrder( latDataSet ) ) )
                    {
                        endian = new ossimEndian();
                    }

                    // Native type:
                    H5::DataType latDataType = latDataSet->getDataType();
                    H5::DataType lonDataType = lonDataSet->getDataType();

                    // Output dataspace always the same, width of one line.
                    H5::DataSpace bufferDataSpace( OUT_DIM_COUNT, &outputCount.front());
                    bufferDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                     &outputCount.front(),
                                                     &outputOffset.front() );

                    //  Arrays to hold a single line of latitude longitude values.
                    vector<ossim_float32> latValue(imageCols);
                    vector<ossim_float32> lonValue(imageCols);
                    hsize_t row = 0;

                    // Line loop:
                    for ( ossim_uint32 y = 0; y < gridRows; ++y )
                    {
                        // row = line in image space
                        row = y*GRID_SIZE;

                        bool hitNans = false;

                        if ( row < imageRows )
                        {
                            inputOffset[0] = row;

                            latDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                          &inputCount.front(),
                                                          &inputOffset.front() );
                            lonDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                          &inputCount.front(),
                                                          &inputOffset.front() );

                            // Read data from file into the buffer.
                            latDataSet->read( &(latValue.front()), latDataType,
                                              bufferDataSpace, latDataSpace );
                            lonDataSet->read( &(lonValue.front()), lonDataType,
                                              bufferDataSpace, lonDataSpace );

                            if ( endian )
                            {
                                // If the endian pointer is initialized(not zero) swap the bytes.
                                endian->swap( &(latValue.front()), imageCols );
                                endian->swap( &(lonValue.front()), imageCols );
                            }

                            // Sample loop:
                            hsize_t col = 0;

                            for ( ossim_uint32 x = 0; x < gridCols; ++x )
                            {
                                ossim_float32 lat = ossim::nan();
                                ossim_float32 lon = ossim::nan();

                                // col = sample in image space
                                col = x*GRID_SIZE;

                                if ( col < imageCols )
                                {
                                    if ( (latValue[col] > NULL_VALUE)&&(lonValue[col] > NULL_VALUE) )
                                    {
                                        lat = latValue[col];
                                        lon = lonValue[col];
                                    }
                                    else
                                    {
                                        hitNans = true;
                                    }
                                }
                                else // Last column is outside of image bounds.
                                {
                                    ossim_float32 latSpacing = ossim::nan();
                                    ossim_float32 lonSpacing = ossim::nan();

                                    // Get the last two latitude values:
                                    ossim_float32 lat1 = latValue[imageCols-2];
                                    ossim_float32 lat2 = latValue[imageCols-1];

                                    // Get the last two longitude values
                                    ossim_float32 lon1 = lonValue[imageCols-2];
                                    ossim_float32 lon2 = lonValue[imageCols-1];

                                    if ( ( lat1 > NULL_VALUE ) && ( lat2 > NULL_VALUE ) )
                                    {
                                        // Delta between last two latitude values.
                                        latSpacing = lat2 - lat1;

                                        // Compute:
                                        lat = lat2 + ( col - (imageCols-1) ) * latSpacing;
                                    }
                                    else
                                    {
                                        hitNans = true;
                                    }

                                    if ( ( lon1 > NULL_VALUE ) && ( lon2 > NULL_VALUE ) )
                                    {
                                        // Consider dateline crossing.
                                        if ( (lon1 > 0.0) && ( lon2 < 0.0 ) )
                                        {
                                            lon2 += 360.0;
                                        }

                                        // Delta between last two longitude values.
                                        lonSpacing = lon2 - lon1;

                                        // Compute:
                                        lon = lon2 + ( col - (imageCols-1) ) * lonSpacing;

                                        // Check for wrap:
                                        if ( lon > 180 )
                                        {
                                            lon -= 360.0;
                                        }
                                    }
                                    else
                                    {
                                        hitNans = true;
                                    }

#if 0 /* Please leave for debug. (drb) */
                                    cout << "lat1: " << lat1 << " lat2 " << lat2
                                         << " lon1 " << lon1  << " lon2 " << lon2
                                         << "\n";
#endif
                                }

                                if ( hitNans )
                                {
                                    std::string errMsg =
                                        "ossimHdfGridModel::setGridNodes encountered nans!";
                                    throw ossimException(errMsg);
                                }

                                // Assign the latitude and longitude.
                                theLatGrid.setNode( x, y, lat );
                                theLonGrid.setNode( x, y, lon );

#if 0 /* Please leave for debug. (drb) */
                                cout << "x,y,col,row,lat,lon:" << x << "," << y << ","
                                     << col << "," << row << ","
                                     << theLatGrid.getNode(x, y)
                                     << "," << theLonGrid.getNode( x, y) << "\n";
#endif

                            } // End sample loop.

                        }
                        else // Row is outside of image bounds:
                        {
                            // Read the last two rows in.
                            vector<ossim_float32> latValue2(imageCols);
                            vector<ossim_float32> lonValue2(imageCols);

                            inputOffset[0] = imageRows-2; // 2nd to last line

                            latDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                          &inputCount.front(),
                                                          &inputOffset.front() );
                            lonDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                          &inputCount.front(),
                                                          &inputOffset.front() );

                            // Read data from file into the buffer.
                            latDataSet->read( &(latValue.front()), latDataType,
                                              bufferDataSpace, latDataSpace );
                            lonDataSet->read( &(lonValue.front()), lonDataType,
                                              bufferDataSpace, lonDataSpace );

                            inputOffset[0] = imageRows-1; // last line

                            latDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                          &inputCount.front(),
                                                          &inputOffset.front() );
                            lonDataSpace.selectHyperslab( H5S_SELECT_SET,
                                                          &inputCount.front(),
                                                          &inputOffset.front() );

                            // Read data from file into the buffer.
                            latDataSet->read( &(latValue2.front()), latDataType,
                                              bufferDataSpace, latDataSpace );
                            lonDataSet->read( &(lonValue2.front()), lonDataType,
                                              bufferDataSpace, lonDataSpace );

                            if ( endian )
                            {
                                // If the endian pointer is initialized(not zero) swap the bytes.
                                endian->swap( &(latValue.front()), imageCols );
                                endian->swap( &(lonValue.front()), imageCols );
                                endian->swap( &(latValue2.front()), imageCols );
                                endian->swap( &(lonValue2.front()), imageCols );
                            }

                            // Sample loop:
                            hsize_t col = 0;
                            for ( ossim_uint32 x = 0; x < gridCols; ++x )
                            {
                                col = x*GRID_SIZE; // Sample in image space.

                                ossim_float32 lat        = ossim::nan();
                                ossim_float32 lat1       = ossim::nan();
                                ossim_float32 lat2       = ossim::nan();
                                ossim_float32 latSpacing = ossim::nan();
                                ossim_float32 lon        = ossim::nan();
                                ossim_float32 lon1       = ossim::nan();
                                ossim_float32 lon2       = ossim::nan();
                                ossim_float32 lonSpacing = ossim::nan();

                                if ( col < imageCols )
                                {
                                    lat1 = latValue[col];
                                    lat2 = latValue2[col];
                                    lon1 = lonValue[col];
                                    lon2 = lonValue2[col];
                                }
                                else // Very last grid point.
                                {
                                    // Compute the missing column for the last two image lines:
                                    lat1 = latValue[imageCols-1] + ( col - (imageCols-1)) *
                                           ( latValue[imageCols-1] - latValue[imageCols-2] );

                                    lat2 = latValue2[imageCols-1] + ( col - (imageCols-1)) *
                                           ( latValue2[imageCols-1] - latValue2[imageCols-2] );

                                    lon1 = lonValue[imageCols-1] + ( col - (imageCols-1)) *
                                           ( lonValue[imageCols-1] - lonValue[imageCols-2] );

                                    lon2 = lonValue2[imageCols-1] + ( col - (imageCols-1)) *
                                           ( lonValue2[imageCols-1] - lonValue2[imageCols-2] );
                                }

#if 0 /* Please leave for debug. (drb) */
                                cout << "lat1: " << lat1 << " lat2 " << lat2
                                     << " lon1 " << lon1  << " lon2 " << lon2
                                     << "\n";
#endif

                                if ( ( lon1 > NULL_VALUE ) && ( lon2 > NULL_VALUE ) )
                                {
                                    // Consider dateline crossing.
                                    if ( (lon1 > 0.0) && ( lon2 < 0.0 ) )
                                    {
                                        lon2 += 360.0;
                                    }

                                    // Delta between last two longitude values.
                                    lonSpacing = lon2 - lon1;

                                    // Compute:
                                    lon = lon2 + ( row - (imageRows-1) ) * lonSpacing;

                                    // Check for wrap:
                                    if ( lon > 180 )
                                    {
                                        lon -= 360.0;
                                    }
                                }
                                else
                                {
                                    hitNans = true;
                                }

                                if ( ( lat1 > NULL_VALUE ) && ( lat2 > NULL_VALUE ) )
                                {
                                    // Delta between last two latitude values.
                                    latSpacing = lat2 - lat1;

                                    // Compute:
                                    lat = lat2 + ( row - (imageRows-1) ) * latSpacing;
                                }
                                else
                                {
                                    hitNans = true;
                                }

                                if ( hitNans )
                                {
                                    std::string errMsg =
                                        "ossimHdfGridModel::setGridNodes encountered nans!";
                                    throw ossimException(errMsg);
                                }

                                // Assign the latitude::
                                theLatGrid.setNode( x, y, lat );

                                // Assign the longitude.
                                theLonGrid.setNode( x, y, lon );

#if 0 /* Please leave for debug. (drb) */
                                cout << "x,y,col,row,lat,lon:" << x << "," << y << ","
                                     << col << "," << row << "," << lat << "," << lon << "\n";
#endif

                            } // End sample loop.

                        } // Matches if ( row < imageRows ){...}else{

                    } // End line loop.

                    latDataSpace.close();
                    lonDataSpace.close();

                    if ( status )
                    {
                        theLatGrid.enableExtrapolation();
                        theLonGrid.enableExtrapolation();
                        theHeightEnabledFlag = false;
                        ossimDrect imageRect(rect);
                        initializeModelParams(imageRect);
                        // debugDump();
                    }

                } // Matches: if ( scalar == OSSIM_FLOAT32 )

            } // Matches: if ( (latDimsOut[0] == imageRows) ...

        } // Matches: if ( ( LAT_DIM_COUNT == 2 ) ...

    } // Matches: if ( latDataSet && lonDataSet

    return status;

} // End: bool ossimHdfGridModel::setGridNodes( H5::DataSet* latDataSet, ... )