File indexing completed on 2024-04-21 03:44:13

 /*
     SPDX-FileCopyrightText: 2017 Jasem Mutlaq <mutlaqja@ikarustech.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "videowg.h"
 #include "collimationoverlaytypes.h"
 
 #include "kstars_debug.h"
 #include "kstarsdata.h"
 #include "kstars.h"
 
 #include <QImageReader>
 #include <QMouseEvent>
 #include <QResizeEvent>
 #include <QRubberBand>
 #include <QSqlTableModel>
 #include <QSqlRecord>
 #include <QtMath>
 
 VideoWG::VideoWG(QWidget *parent) : QLabel(parent)
 {
     streamImage.reset(new QImage());
 
     grayTable.resize(256);
 
     for (int i = 0; i < 256; i++)
         grayTable[i] = qRgb(i, i, i);
 }
 
 bool VideoWG::newBayerFrame(IBLOB *bp, const BayerParams &params)
 {
     return debayer(bp, params);
 }
 
 bool VideoWG::newFrame(IBLOB *bp)
 {
     if (bp->size <= 0)
         return false;
 
     bool rc = false;
     QString format(bp->format);
     if (m_RawFormat != format)
     {
         format.remove('.');
         format.remove("stream_");
         m_RawFormatSupported = QImageReader::supportedImageFormats().contains(format.toLatin1());
         m_RawFormat = format;
     }
 
     if (m_RawFormatSupported)
         rc = streamImage->loadFromData(static_cast<uchar *>(bp->blob), bp->size);
     else if (static_cast<uint32_t>(bp->size) == totalBaseCount)
     {
         streamImage.reset(new QImage(static_cast<uchar *>(bp->blob), streamW, streamH, QImage::Format_Indexed8));
         streamImage->setColorTable(grayTable);
         rc = !streamImage->isNull();
     }
     else if (static_cast<uint32_t>(bp->size) == totalBaseCount * 3)
     {
         streamImage.reset(new QImage(static_cast<uchar *>(bp->blob), streamW, streamH, QImage::Format_RGB888));
         rc = !streamImage->isNull();
     }
 
     if (rc)
     {
         kPix = QPixmap::fromImage(streamImage->scaled(size(), Qt::KeepAspectRatio));
 
         paintOverlay(kPix);
 
         setPixmap(kPix);
     }
 
     emit imageChanged(streamImage);
 
     return rc;
 }
 
 bool VideoWG::save(const QString &filename, const char *format)
 {
     return kPix.save(filename, format);
 }
 
 void VideoWG::setSize(uint16_t w, uint16_t h)
 {
     streamW        = w;
     streamH        = h;
     totalBaseCount = w * h;
 }
 
 //void VideoWG::resizeEvent(QResizeEvent *ev)
 //{
 //    setPixmap(QPixmap::fromImage(streamImage->scaled(ev->size(), Qt::KeepAspectRatio)));
 //    ev->accept();
 //}
 
 void VideoWG::mousePressEvent(QMouseEvent *event)
 {
     origin = event->pos();
     if (!rubberBand)
         rubberBand = new QRubberBand(QRubberBand::Rectangle, this);
     rubberBand->setGeometry(QRect(origin, QSize()));
     rubberBand->show();
 }
 
 void VideoWG::mouseMoveEvent(QMouseEvent *event)
 {
     rubberBand->setGeometry(QRect(origin, event->pos()).normalized());
 }
 
 void VideoWG::mouseReleaseEvent(QMouseEvent *event)
 {
     rubberBand->hide();
 
     if (event->button() == Qt::RightButton)
     {
         emit newSelection(QRect());
         return;
     }
 
     QRect rawSelection = rubberBand->geometry();
     int pixmapX        = (width() - kPix.width()) / 2;
     int pixmapY        = (height() - kPix.height()) / 2;
 
     QRect finalSelection;
 
     double scaleX = static_cast<double>(streamImage->width()) / kPix.width();
     double scaleY = static_cast<double>(streamImage->height()) / kPix.height();
 
     finalSelection.setX((rawSelection.x() - pixmapX) * scaleX);
     finalSelection.setY((rawSelection.y() - pixmapY) * scaleY);
     finalSelection.setWidth(rawSelection.width() * scaleX);
     finalSelection.setHeight(rawSelection.height() * scaleY);
 
     emit newSelection(finalSelection);
     // determine selection, for example using QRect::intersects()
     // and QRect::contains().
 }
 
 bool VideoWG::debayer(const IBLOB *bp, const BayerParams &params)
 {
     uint32_t rgb_size = streamW * streamH * 3;
     auto * destinationBuffer = new uint8_t[rgb_size];
 
     if (destinationBuffer == nullptr)
     {
         qCCritical(KSTARS) << "Unable to allocate memory for temporary bayer buffer.";
         return false;
     }
 
     int ds1394_height = streamH;
 
     uint8_t * dc1394_source = reinterpret_cast<uint8_t*>(bp->blob);
     if (params.offsetY == 1)
     {
         dc1394_source += streamW;
         ds1394_height--;
     }
     if (params.offsetX == 1)
     {
         dc1394_source++;
     }
     dc1394error_t error_code = dc1394_bayer_decoding_8bit(dc1394_source, destinationBuffer, streamW, ds1394_height,
                                params.filter, params.method);
 
     if (error_code != DC1394_SUCCESS)
     {
         qCCritical(KSTARS) << "Debayer failed" << error_code;
         delete[] destinationBuffer;
         return false;
     }
 
     streamImage.reset(new QImage(destinationBuffer, streamW, streamH, QImage::Format_RGB888));
     bool rc = !streamImage->isNull();
 
     if (rc)
     {
         kPix = QPixmap::fromImage(streamImage->scaled(size(), Qt::KeepAspectRatio));
 
         paintOverlay(kPix);
 
         setPixmap(kPix);
     }
 
     emit imageChanged(streamImage);
 
     delete[] destinationBuffer;
     return rc;
 }
 
 void VideoWG::paintOverlay(QPixmap &imagePix)
 {
     if (!overlayEnabled || m_EnabledOverlayElements.count() == 0) return;
 
     // Anchor - default to center of image
     QPointF m_anchor (static_cast<float>(kPix.width() / 2), static_cast<float>(kPix.height()/2));
     scale = (static_cast<float>(kPix.width()) / static_cast<float>(streamW));
 
     // Apply any offset from (only) the first enabled anchor element
     bool foundAnchor = false;
     for (auto &oneElement : m_EnabledOverlayElements) {
         if (oneElement["Type"] == "Anchor" && !foundAnchor) {
             m_anchor.setX(m_anchor.x() + oneElement["OffsetX"].toInt());
             m_anchor.setY(m_anchor.y() + oneElement["OffsetY"].toInt());
             foundAnchor = true;
         }
     }
 
     painter->begin(&imagePix);
     painter->translate(m_anchor);
     painter->scale(scale, scale);
 
     for (auto &currentElement : m_EnabledOverlayElements) {
 
         painter->save();
         QPen m_pen = QPen(QColor(currentElement["Colour"].toString()));
         m_pen.setWidth(currentElement["Thickness"].toUInt());
         m_pen.setCapStyle(Qt::FlatCap);
         m_pen.setJoinStyle(Qt::MiterJoin);
         painter->setPen(m_pen);
         painter->translate(currentElement["OffsetX"].toFloat(), currentElement["OffsetY"].toFloat());
 
         int m_count = currentElement["Count"].toUInt();
         float m_pcd = currentElement["PCD"].toFloat();
 
         if (m_count == 1) {
             PaintOneItem(currentElement["Type"].toString(), QPointF(0.0, 0.0), currentElement["SizeX"].toUInt(), currentElement["SizeY"].toUInt(), currentElement["Thickness"].toUInt());
         } else if (m_count > 1) {
             float slice = 360 / m_count;
             for (int i = 0; i < m_count; i++) {
                 painter->save();
                 painter->rotate((slice * i) + currentElement["Rotation"].toFloat());
                 PaintOneItem(currentElement["Type"].toString(), QPointF((m_pcd / 2), 0.0), currentElement["SizeX"].toUInt(), currentElement["SizeY"].toUInt(), currentElement["Thickness"].toUInt());
                 painter->restore();
             }
         }
 
         painter->restore();
      }
     painter->end();
 }
 
 void VideoWG::setupOverlay ()
 {
     if (overlayEnabled) {
         initOverlayModel();
 
         typeValues = new QStringList;
         collimationoverlaytype m_types;
         const QMetaObject *m_metaobject = m_types.metaObject();
         QMetaEnum m_metaEnum = m_metaobject->enumerator(m_metaobject->indexOfEnumerator("Types"));
         for (int i = 0; i < m_metaEnum.keyCount(); i++) {
             *typeValues << tr(m_metaEnum.key(i));
         }
 
         painter = new QPainter;
     }
 }
 
 void VideoWG::initOverlayModel()
 {
     m_CollimationOverlayElements.clear();
     auto userdb = QSqlDatabase::database(KStarsData::Instance()->userdb()->connectionName());
     m_CollimationOverlayElementsModel = new QSqlTableModel(this, userdb);
     modelChanged();
 }
 
 void VideoWG::modelChanged()
 {
     m_CollimationOverlayElements.clear();
     m_EnabledOverlayElements.clear();
     KStars::Instance()->data()->userdb()->GetCollimationOverlayElements(m_CollimationOverlayElements);
     for (auto &oneElement : m_CollimationOverlayElements)
         if (oneElement["Enabled"] == Qt::Checked)
             m_EnabledOverlayElements.append(oneElement);
 }
 
 void VideoWG::PaintOneItem (QString type, QPointF position, int sizeX, int sizeY, int thickness)
 {
     float m_sizeX = sizeX - (thickness / 2);
     float m_sizeY = sizeY - (thickness / 2);
 
     switch (typeValues->indexOf(type)) {
 case 0: // Anchor - ignore as we're not drawing it
     break;
 
 case 1: // Ellipse
     painter->drawEllipse(position, m_sizeX, m_sizeY);
     break;
 
 case 2: // Rectangle
 {
     QRect m_rect((position.x() - (m_sizeX / 2)), (position.y() - (m_sizeY / 2)), (m_sizeX - (thickness / 2)), (m_sizeY - (thickness / 2)));
     painter->drawRect(m_rect);
     break;
 }
 
 case 3: // Line
     painter->drawLine(position.x(), position.y(), sizeX, sizeY);
     break;
 
 default:
     break;
     };
 }
 
 void VideoWG::toggleOverlay()
 {
     if (overlayEnabled == false) {
         overlayEnabled = true;
         if (m_CollimationOverlayElementsModel == nullptr) {
             setupOverlay();
         }
     } else if (overlayEnabled == true) {
         overlayEnabled = false;
     }
 }
 
 VideoWG::~VideoWG()
 {
     delete m_CollimationOverlayElementsModel;
     delete m_CurrentElement;
     delete typeValues;
     delete painter;
 }