File indexing completed on 2024-04-14 03:43:11

 /*
     SPDX-FileCopyrightText: 2022 Jasem Mutlaq <mutlaqja@ikarustech.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <QPainter>
 
 #include "mosaictiles.h"
 #include "kstarsdata.h"
 #include "Options.h"
 
 MosaicTiles::MosaicTiles() : SkyObject()
 {
     setName(QLatin1String("Mosaic Tiles"));
 
     m_Brush.setStyle(Qt::NoBrush);
     m_Pen.setColor(QColor(200, 200, 200, 100));
     m_Pen.setWidth(1);
 
     m_TextBrush.setStyle(Qt::SolidPattern);
     m_TextPen.setColor(Qt::red);
     m_TextPen.setWidth(2);
 
     m_FocalLength = Options::telescopeFocalLength();
     m_FocalReducer = Options::telescopeFocalReducer();
     m_CameraSize.setWidth(Options::cameraWidth());
     m_CameraSize.setHeight(Options::cameraHeight());
     m_PixelSize.setWidth(Options::cameraPixelWidth());
     m_PixelSize.setHeight(Options::cameraPixelHeight());
     m_PositionAngle = Options::cameraRotation();
 
     // Initially for 1x1 Grid
     m_MosaicFOV = m_CameraFOV = calculateCameraFOV();
 
     createTiles(false);
 }
 
 MosaicTiles::~MosaicTiles()
 {
 }
 
 bool MosaicTiles::isValid() const
 {
     return m_MosaicFOV.width() > 0 && m_MosaicFOV.height() > 0;
 }
 
 void MosaicTiles::setPositionAngle(double value)
 {
     m_PositionAngle = value;
 }
 
 void MosaicTiles::setOverlap(double value)
 {
     m_Overlap = (value < 0) ? 0 : (value > 100) ? 100 : value;
 }
 
 std::shared_ptr<MosaicTiles::OneTile> MosaicTiles::oneTile(int row, int col)
 {
     int offset = row * m_GridSize.width() + col;
 
     if (offset < 0 || offset >= m_Tiles.size())
         return nullptr;
 
     return m_Tiles[offset];
 }
 
 bool MosaicTiles::fromXML(const QString &filename)
 {
     QFile sFile;
     sFile.setFileName(filename);
 
     if (!sFile.open(QIODevice::ReadOnly))
         return false;
 
     LilXML *xmlParser = newLilXML();
     char errmsg[2048] = {0};
     XMLEle *root = nullptr;
     XMLEle *ep   = nullptr;
     char c;
 
     m_OperationMode = MODE_OPERATION;
 
     m_Tiles.clear();
 
     // We expect all data read from the XML to be in the C locale - QLocale::c()
     QLocale cLocale = QLocale::c();
 
     bool mosaicInfoFound = false;
     int index = 1;
 
     m_TrackChecked = m_FocusChecked = m_AlignChecked = m_GuideChecked = false;
 
     while (sFile.getChar(&c))
     {
         root = readXMLEle(xmlParser, c, errmsg);
 
         if (root)
         {
             for (ep = nextXMLEle(root, 1); ep != nullptr; ep = nextXMLEle(root, 0))
             {
                 const char *tag = tagXMLEle(ep);
                 if (!strcmp(tag, "Mosaic"))
                 {
                     mosaicInfoFound = true;
                     XMLEle *subEP = nullptr;
                     for (subEP = nextXMLEle(ep, 1); subEP != nullptr; subEP = nextXMLEle(ep, 0))
                     {
                         const char *subTag = tagXMLEle(subEP);
                         if (!strcmp(subTag, "Target"))
                             setTargetName(pcdataXMLEle(subEP));
                         else if (!strcmp(subTag, "Group"))
                             setGroup(pcdataXMLEle(subEP));
                         else if (!strcmp(subTag, "FinishSequence"))
                             setCompletionCondition(subTag);
                         else if (!strcmp(subTag, "FinishRepeat"))
                             setCompletionCondition(subTag, pcdataXMLEle(subEP));
                         else if (!strcmp(subTag, "FinishSLoop"))
                             setCompletionCondition(subTag);
                         else if (!strcmp(subTag, "Sequence"))
                             setSequenceFile(pcdataXMLEle(subEP));
                         else if (!strcmp(subTag, "Directory"))
                             setOutputDirectory(pcdataXMLEle(subEP));
                         else if (!strcmp(subTag,  "FocusEveryN"))
                             setFocusEveryN(cLocale.toInt(pcdataXMLEle(subEP)));
                         else if (!strcmp(subTag, "AlignEveryN"))
                             setAlignEveryN(cLocale.toInt(pcdataXMLEle(subEP)));
                         else if (!strcmp(subTag,  "TrackChecked"))
                             m_TrackChecked = true;
                         else if (!strcmp(subTag,  "FocusChecked"))
                             m_FocusChecked = true;
                         else if (!strcmp(subTag, "AlignChecked"))
                             m_AlignChecked = true;
                         else if (!strcmp(subTag, "GuideChecked"))
                             m_GuideChecked = true;
                         else if (!strcmp(subTag, "Overlap"))
                             setOverlap(cLocale.toDouble(pcdataXMLEle(subEP)));
                         else if (!strcmp(subTag, "CenterRA"))
                         {
                             dms ra;
                             ra.setH(cLocale.toDouble(pcdataXMLEle(subEP)));
                             setRA0(ra);
                         }
                         else if (!strcmp(subTag, "CenterDE"))
                         {
                             dms de;
                             de.setD(cLocale.toDouble(pcdataXMLEle(subEP)));
                             setDec0(de);
                         }
                         else if (!strcmp(subTag, "GridW"))
                             m_GridSize.setWidth(cLocale.toInt(pcdataXMLEle(subEP)));
                         else if (!strcmp(subTag, "GridH"))
                             m_GridSize.setHeight(cLocale.toInt(pcdataXMLEle(subEP)));
                         else if (!strcmp(subTag, "FOVW"))
                             m_MosaicFOV.setWidth(cLocale.toDouble(pcdataXMLEle(subEP)));
                         else if (!strcmp(subTag, "FOVH"))
                             m_MosaicFOV.setHeight(cLocale.toDouble(pcdataXMLEle(subEP)));
                         else if (!strcmp(subTag, "CameraFOVW"))
                             m_CameraFOV.setWidth(cLocale.toDouble(pcdataXMLEle(subEP)));
                         else if (!strcmp(subTag, "CameraFOVH"))
                             m_CameraFOV.setHeight(cLocale.toDouble(pcdataXMLEle(subEP)));
                     }
                 }
                 else if (mosaicInfoFound && !strcmp(tag, "Job"))
                     processJobInfo(ep, index++);
             }
             delXMLEle(root);
         }
         else if (errmsg[0])
         {
             delLilXML(xmlParser);
             return false;
         }
     }
 
     delLilXML(xmlParser);
     if (mosaicInfoFound)
         updateCoordsNow(KStarsData::Instance()->updateNum());
     return mosaicInfoFound;
 }
 
 bool MosaicTiles::processJobInfo(XMLEle *root, int index)
 {
     XMLEle *ep;
     XMLEle *subEP;
 
     // We expect all data read from the XML to be in the C locale - QLocale::c()
     QLocale cLocale = QLocale::c();
 
     OneTile newTile;
     for (ep = nextXMLEle(root, 1); ep != nullptr; ep = nextXMLEle(root, 0))
     {
         newTile.index = index;
         if (!strcmp(tagXMLEle(ep), "Coordinates"))
         {
             subEP = findXMLEle(ep, "J2000RA");
             if (subEP)
             {
                 dms ra;
                 ra.setH(cLocale.toDouble(pcdataXMLEle(subEP)));
                 newTile.skyCenter.setRA0(ra);
             }
             subEP = findXMLEle(ep, "J2000DE");
             if (subEP)
             {
                 dms de;
                 de.setD(cLocale.toDouble(pcdataXMLEle(subEP)));
                 newTile.skyCenter.setDec0(de);
             }
         }
         else if (!strcmp(tagXMLEle(ep), "TileCenter"))
         {
             if ((subEP = findXMLEle(ep, "X")))
                 newTile.center.setX(cLocale.toDouble(pcdataXMLEle(subEP)));
             if ((subEP = findXMLEle(ep, "Y")))
                 newTile.center.setY(cLocale.toDouble(pcdataXMLEle(subEP)));
             if ((subEP = findXMLEle(ep, "Rotation")))
                 newTile.rotation = cLocale.toDouble(pcdataXMLEle(subEP));
         }
         else if (!strcmp(tagXMLEle(ep), "PositionAngle"))
         {
             m_PositionAngle = cLocale.toDouble(pcdataXMLEle(ep));
         }
     }
 
     newTile.skyCenter.updateCoordsNow(KStarsData::Instance()->updateNum());
     appendTile(newTile);
     return true;
 }
 
 
 //bool MosaicTiles::toJSON(QJsonObject &output)
 //{
 //    Q_UNUSED(output)
 //    return false;
 //}
 
 //bool MosaicTiles::fromJSON(const QJsonObject &input)
 //{
 //    Q_UNUSED(input)
 //    return false;
 //}
 
 void MosaicTiles::appendTile(const OneTile &value)
 {
     m_Tiles.append(std::make_shared<OneTile>(value));
 }
 
 void MosaicTiles::appendEmptyTile()
 {
     m_Tiles.append(std::make_shared<OneTile>());
 }
 
 void MosaicTiles::clearTiles()
 {
     m_Tiles.clear();
 }
 
 QSizeF MosaicTiles::adjustCoordinate(QPointF tileCoord)
 {
     // Compute the declination of the tile row from the mosaic center
     double const dec = dec0().Degrees() + tileCoord.y() / 60.0;
 
     // Adjust RA based on the shift in declination
     QSizeF const toSpherical(1 / cos(dec * dms::DegToRad), 1);
 
     // Return the adjusted coordinates as a QSizeF in degrees
     return QSizeF(tileCoord.x() / 60.0 * toSpherical.width(), tileCoord.y() / 60.0 * toSpherical.height());
 }
 
 void MosaicTiles::createTiles(bool s_shaped)
 {
     m_SShaped = s_shaped;
     updateTiles();
 }
 
 void MosaicTiles::updateTiles()
 {
     // Sky map has objects moving from left to right, so configure the mosaic from right to left, column per column
     const auto fovW = m_CameraFOV.width();
     const auto fovH = m_CameraFOV.height();
     const auto gridW = m_GridSize.width();
     const auto gridH = m_GridSize.height();
 
     // Offset is our tile size with an overlap removed
     double const xOffset = fovW * (1 - m_Overlap / 100.0);
     double const yOffset = fovH * (1 - m_Overlap / 100.0);
 
     // We start at top right corner, (0,0) being the center of the tileset
     double initX = +(fovW + xOffset * (gridW - 1)) / 2.0 - fovW;
     double initY = -(fovH + yOffset * (gridH - 1)) / 2.0;
 
     double x = initX, y = initY;
 
     //    qCDebug(KSTARS_EKOS_SCHEDULER) << "Mosaic Tile FovW" << fovW << "FovH" << fovH << "initX" << x << "initY" << y <<
     //                                   "Offset X " << xOffset << " Y " << yOffset << " rotation " << pa << " reverseOdd " << s_shaped;
 
     // Start by clearing existing tiles.
     clearTiles();
 
     int index = 0;
     for (int col = 0; col < gridW; col++)
     {
         y = (m_SShaped && (col % 2)) ? (y - yOffset) : initY;
 
         for (int row = 0; row < gridH; row++)
         {
             QPointF pos(x, y);
             QPointF tile_center(pos.x() + (fovW / 2.0), pos.y() + (fovH / 2.0));
 
             // The location of the tile on the sky map refers to the center of the mosaic, and rotates with the mosaic itself
             const auto tileSkyLocation = QPointF(0, 0) - rotatePoint(tile_center, QPointF(), m_PositionAngle);
 
             // Compute the adjusted location in RA/DEC
             const auto tileSkyOffsetScaled = adjustCoordinate(tileSkyLocation);
 
             auto adjusted_ra0 = (ra0().Degrees() + tileSkyOffsetScaled.width()) / 15.0;
             auto adjusted_de0 = (dec0().Degrees() + tileSkyOffsetScaled.height());
             SkyPoint sky_center(adjusted_ra0, adjusted_de0);
             sky_center.apparentCoord(static_cast<long double>(J2000), KStarsData::Instance()->ut().djd());
 
             auto tile_center_ra0 = sky_center.ra0().Degrees();
             auto mosaic_center_ra0 = ra0().Degrees();
             auto rotation =  tile_center_ra0 - mosaic_center_ra0;
 
             // Large rotations handled wrong by the algorithm - prefer doing multiple mosaics
             if (abs(rotation) <= 90.0)
             {
                 auto next_index = ++index;
                 MosaicTiles::OneTile tile = {pos, tile_center, sky_center, rotation, next_index};
                 appendTile(tile);
             }
             else
             {
                 appendEmptyTile();
             }
 
             y += (m_SShaped && (col % 2)) ? -yOffset : +yOffset;
         }
 
         x -= xOffset;
     }
 }
 
 void MosaicTiles::draw(QPainter *painter)
 {
     if (m_Tiles.size() == 0)
         return;
 
     auto pixelScale = Options::zoomFactor() * dms::DegToRad / 60.0;
     const auto fovW = m_CameraFOV.width() * pixelScale;
     const auto fovH = m_CameraFOV.height() * pixelScale;
     const auto mosaicFOVW = m_MosaicFOV.width() * pixelScale;
     const auto mosaicFOVH = m_MosaicFOV.height() * pixelScale;
     const auto gridW = m_GridSize.width();
     const auto gridH = m_GridSize.height();
 
     QFont defaultFont = painter->font();
     QRect const oneRect(-fovW / 2, -fovH / 2, fovW, fovH);
 
     auto alphaValue = m_PainterAlpha;
 
     if (m_PainterAlphaAuto)
     {
         // Tiles should be more transparent when many are overlapped
         // Overlap < 50%: low transparency, as only two tiles will overlap on a line
         // 50% < Overlap < 75%: mid transparency, as three tiles will overlap one a line
         // 75% < Overlap: high transparency, as four tiles will overlap on a line
         // Slider controlling transparency provides [5%,50%], which is scaled to 0-200 alpha.
 
         if (m_Tiles.size() > 1)
             alphaValue = (40 - m_Overlap / 2);
         else
             alphaValue = 40;
     }
 
     // Draw a light background field first to help detect holes - reduce alpha as we are stacking tiles over this
     painter->setBrush(QBrush(QColor(255, 0, 0, (200 * alphaValue) / 100), Qt::SolidPattern));
     painter->setPen(QPen(painter->brush(), 2, Qt::PenStyle::DotLine));
     painter->drawRect(QRectF(QPointF(-mosaicFOVW / 2, -mosaicFOVH / 2), QSizeF(mosaicFOVW, mosaicFOVH)));
 
     // Fill tiles with a transparent brush to show overlaps
     QBrush tileBrush(QColor(0, 255, 0, (200 * alphaValue) / 100), Qt::SolidPattern);
 
     // Draw each tile, adjusted for rotation
     for (int row = 0; row < gridH; row++)
     {
         for (int col = 0; col < gridW; col++)
         {
             auto tile = oneTile(row, col);
             if (tile)
             {
                 painter->save();
 
                 painter->translate(tile->center * pixelScale);
                 painter->rotate(tile->rotation);
 
                 painter->setBrush(tileBrush);
                 painter->setPen(m_Pen);
 
                 painter->drawRect(oneRect);
 
                 painter->restore();
             }
         }
     }
 
     // Overwrite with tile information
     for (int row = 0; row < gridH; row++)
     {
         for (int col = 0; col < gridW; col++)
         {
             auto tile = oneTile(row, col);
             if (tile)
             {
                 painter->save();
 
                 painter->translate(tile->center * pixelScale);
                 // Add 180 to match Position Angle per the standard definition
                 // when camera image is read bottom-up instead of KStars standard top-bottom.
                 //painter->rotate(tile->rotation + 180);
 
                 painter->rotate(tile->rotation);
 
                 painter->setBrush(m_TextBrush);
                 painter->setPen(m_TextPen);
 
                 defaultFont.setPointSize(qMax(1., 4 * pixelScale * m_CameraFOV.width() / 60.));
                 painter->setFont(defaultFont);
                 painter->drawText(oneRect, Qt::AlignRight | Qt::AlignTop, QString("%1.").arg(tile->index));
 
                 defaultFont.setPointSize(qMax(1., 4 * pixelScale * m_CameraFOV.width() / 60.));
                 painter->setFont(defaultFont);
                 painter->drawText(oneRect, Qt::AlignHCenter | Qt::AlignVCenter, QString("%1\n%2")
                                   .arg(tile->skyCenter.ra0().toHMSString(), tile->skyCenter.dec0().toDMSString()));
                 painter->drawText(oneRect, Qt::AlignHCenter | Qt::AlignBottom, QString("%1%2°")
                                   .arg(tile->rotation >= 0.01 ? '+' : tile->rotation <= -0.01 ? '-' : '~')
                                   .arg(abs(tile->rotation), 5, 'f', 2));
 
                 painter->restore();
             }
         }
     }
 }
 
 QPointF MosaicTiles::rotatePoint(QPointF pointToRotate, QPointF centerPoint, double paDegrees)
 {
     if (paDegrees < 0)
         paDegrees += 360;
     double angleInRadians = -paDegrees * dms::DegToRad;
     double cosTheta       = cos(angleInRadians);
     double sinTheta       = sin(angleInRadians);
 
     QPointF rotation_point;
 
     rotation_point.setX((cosTheta * (pointToRotate.x() - centerPoint.x()) -
                          sinTheta * (pointToRotate.y() - centerPoint.y()) + centerPoint.x()));
     rotation_point.setY((sinTheta * (pointToRotate.x() - centerPoint.x()) +
                          cosTheta * (pointToRotate.y() - centerPoint.y()) + centerPoint.y()));
 
     return rotation_point;
 }
 
 QSizeF MosaicTiles::calculateTargetMosaicFOV() const
 {
     const auto xFOV = m_CameraFOV.width() * (1 - m_Overlap / 100.0);
     const auto yFOV = m_CameraFOV.height() * (1 - m_Overlap / 100.0);
     return QSizeF(xFOV, yFOV);
 }
 
 QSize MosaicTiles::mosaicFOVToGrid() const
 {
     // Else we get one tile, plus as many overlapping camera FOVs in the remnant of the target FOV
     const auto xFOV = m_CameraFOV.width() * (1 - m_Overlap / 100.0);
     const auto yFOV = m_CameraFOV.height() * (1 - m_Overlap / 100.0);
     const auto xTiles = 1 + ceil((m_MosaicFOV.width() - m_CameraFOV.width()) / xFOV);
     const auto yTiles = 1 + ceil((m_MosaicFOV.height() - m_CameraFOV.height()) / yFOV);
     return QSize(xTiles, yTiles);
 }
 
 QSizeF MosaicTiles::calculateCameraFOV() const
 {
     auto reducedFocalLength = m_FocalLength * m_FocalReducer;
     // Calculate FOV in arcmins
     double const fov_x =
         206264.8062470963552 * m_CameraSize.width() * m_PixelSize.width() / 60000.0 / reducedFocalLength;
     double const fov_y =
         206264.8062470963552 * m_CameraSize.height() * m_PixelSize.height() / 60000.0 / reducedFocalLength;
     return QSizeF(fov_x, fov_y);
 }
 
 void MosaicTiles::syncFOVs()
 {
     m_CameraFOV = calculateCameraFOV();
     m_MosaicFOV = calculateTargetMosaicFOV();
 }