File indexing completed on 2024-04-21 14:43:59

 /*
     SPDX-FileCopyrightText: 2013 Akarsh Simha <akarsh.simha@kdemail.net>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 /* Project Includes */
 #include "imageexporter.h"
 #include "kstars.h"
 #include "skyqpainter.h"
 #include "skymap.h"
 
 #include <KJob>
 #include <KIO/StoredTransferJob>
 
 /* Qt Includes */
 #include <QTemporaryFile>
 #include <QStatusBar>
 #include <QSvgGenerator>
 #include <QApplication>
 
 ImageExporter::ImageExporter(QObject *parent) : QObject(parent), m_includeLegend(false), m_Size(nullptr)
 {
     m_Legend = new Legend;
 
     // set font for legend labels
     m_Legend->setFont(QFont("Courier New", 8));
 
     // set up the default alpha
     setLegendAlpha(160);
 }
 
 void ImageExporter::exportSvg(const QString &fileName)
 {
     SkyMap *map = SkyMap::Instance();
 
     // export as SVG
     QSvgGenerator svgGenerator;
     svgGenerator.setFileName(fileName);
     svgGenerator.setTitle(i18n("KStars Exported Sky Image"));
     svgGenerator.setDescription(i18n("KStars Exported Sky Image"));
     svgGenerator.setSize(QSize(map->width(), map->height()));
     svgGenerator.setResolution(qMax(map->logicalDpiX(), map->logicalDpiY()));
     svgGenerator.setViewBox(QRect(0, 0, map->width(), map->height()));
 
     SkyQPainter painter(KStars::Instance(), &svgGenerator);
     painter.begin();
 
     map->exportSkyImage(&painter);
 
     if (m_includeLegend)
     {
         addLegend(&painter);
     }
 
     painter.end();
 }
 
 bool ImageExporter::exportRasterGraphics(const QString &fileName)
 {
     //Determine desired image format from filename extension
     QString ext = fileName.mid(fileName.lastIndexOf(".") + 1);
 
     // export as raster graphics
     const char *format = "PNG";
 
     if (ext.toLower() == "png")
     {
         format = "PNG";
     }
     else if (ext.toLower() == "jpg" || ext.toLower() == "jpeg")
     {
         format = "JPG";
     }
     else if (ext.toLower() == "gif")
     {
         format = "GIF";
     }
     else if (ext.toLower() == "pnm")
     {
         format = "PNM";
     }
     else if (ext.toLower() == "bmp")
     {
         format = "BMP";
     }
     else
     {
         qWarning() << "Could not parse image format of" << fileName << "assuming PNG";
     }
 
     SkyMap *map = SkyMap::Instance();
 
     int width, height;
     if (m_Size)
     {
         width  = m_Size->width();
         height = m_Size->height();
     }
     else
     {
         width  = map->width();
         height = map->height();
     }
 
     QPixmap skyimage(map->width(), map->height());
     QPixmap outimage(width, height);
     outimage.fill();
 
     map->exportSkyImage(&skyimage);
     qApp->processEvents();
 
     //skyImage is the size of the sky map.  The requested image size is w x h.
     //If w x h is smaller than the skymap, then we simply crop the image.
     //If w x h is larger than the skymap, pad the skymap image with a white border.
     if (width == map->width() && height == map->height())
     {
         outimage = skyimage.copy();
     }
 
     else
     {
         int dx(0), dy(0), sx(0), sy(0);
         int sw(map->width()), sh(map->height());
 
         if (width > map->width())
         {
             dx = (width - map->width()) / 2;
         }
 
         else
         {
             sx = (map->width() - width) / 2;
             sw = width;
         }
 
         if (height > map->height())
         {
             dy = (height - map->height()) / 2;
         }
 
         else
         {
             sy = (map->height() - height) / 2;
             sh = height;
         }
 
         QPainter p;
         p.begin(&outimage);
         p.fillRect(outimage.rect(), QBrush(Qt::white));
         p.drawImage(dx, dy, skyimage.toImage(), sx, sy, sw, sh);
         p.end();
     }
 
     if (m_includeLegend)
     {
         addLegend(&outimage);
     }
 
     if (!outimage.save(fileName, format))
     {
         m_lastErrorMessage = i18n("Error: Unable to save image: %1", fileName);
         qDebug() << Q_FUNC_INFO << m_lastErrorMessage;
         return false;
     }
 
     else
     {
         KStars::Instance()->statusBar()->showMessage(i18n("Saved image to %1", fileName));
         return true;
     }
 }
 void ImageExporter::addLegend(SkyQPainter *painter)
 {
     m_Legend->paintLegend(painter);
 }
 
 void ImageExporter::addLegend(QPaintDevice *pd)
 {
     SkyQPainter painter(KStars::Instance(), pd);
     painter.begin();
 
     addLegend(&painter);
 
     painter.end();
 }
 
 bool ImageExporter::exportImage(QString url)
 {
     QUrl fileURL = QUrl::fromUserInput(url);
 
     m_lastErrorMessage = QString();
     if (fileURL.isValid())
     {
         QTemporaryFile tmpfile;
         QString fname;
         bool isLocalFile = fileURL.isLocalFile();
 
         if (isLocalFile)
         {
             fname = fileURL.toLocalFile();
         }
 
         else
         {
             tmpfile.open();
             fname = tmpfile.fileName();
         }
 
         //Determine desired image format from filename extension
         QString ext = fname.mid(fname.lastIndexOf(".") + 1);
         if (ext.toLower() == "svg")
         {
             exportSvg(fname);
         }
 
         else
         {
             return exportRasterGraphics(fname);
         }
 
         if (!isLocalFile)
         {
             //attempt to upload image to remote location
             KIO::StoredTransferJob *put_job = KIO::storedHttpPost(&tmpfile, fileURL, -1);
             //if(!KIO::NetAccess::upload(tmpfile.fileName(), fileURL, m_KStars))
             if (put_job->exec() == false)
             {
                 m_lastErrorMessage = i18n("Could not upload image to remote location: %1", fileURL.url());
                 qWarning() << m_lastErrorMessage;
                 return false;
             }
         }
         return true;
     }
     m_lastErrorMessage = i18n("Could not export image: URL %1 invalid", fileURL.url());
     qWarning() << m_lastErrorMessage;
     return false;
 }
 
 void ImageExporter::setLegendProperties(Legend::LEGEND_TYPE type, Legend::LEGEND_ORIENTATION orientation,
                                         Legend::LEGEND_POSITION position, int alpha, bool include)
 {
     // set background color (alpha)
     setLegendAlpha(alpha);
     // set legend orientation
     m_Legend->setOrientation(orientation);
 
     // set legend type
     m_Legend->setType(type);
 
     // set legend position
     m_Legend->setPosition(position);
 
     m_includeLegend = include;
 }
 
 ImageExporter::~ImageExporter()
 {
     delete m_Legend;
 }
 
 void ImageExporter::setRasterOutputSize(const QSize *size)
 {
     if (size)
         m_Size = new QSize(*size); // make a copy, so it's safe if the original gets deleted
     else
         m_Size = nullptr;
 }
 
 void ImageExporter::setLegendAlpha(int alpha)
 {
     Q_ASSERT(alpha >= 0 && alpha <= 255);
     Q_ASSERT(m_Legend);
     QColor bgColor = m_Legend->getBgColor();
     bgColor.setAlpha(alpha);
     m_Legend->setBgColor(bgColor);
 }