Fix exceptions and errors in analyzing code

loadrunable.cpp

@@ -384,135 +384,143 @@ bool loadXISF(const QString &path, ImageInfoData &info, RawImage **image)
 
 void LoadRunable::run()
 {
-    if(!m_thumbnail && !m_receiver->isCurrent())
+    try
     {
-        return;
-    }
-    QElapsedTimer timer;
-    ImageInfoData info;
-    QFileInfo finfo(m_file);
-    info.info.append({QObject::tr("Filename"), finfo.fileName()});
 
-    RawImage *rawImage = nullptr;
+        if(!m_thumbnail && !m_receiver->isCurrent())
-    bool raw = false;
-    timer.start();
-    if(m_file.endsWith(".CR2", Qt::CaseInsensitive) || m_file.endsWith(".NEF", Qt::CaseInsensitive) || m_file.endsWith(".DNG", Qt::CaseInsensitive))
-    {
-        loadRAW(m_file, info, &rawImage);
-        raw = true;
-        qDebug() << "LoadRAW" << timer.elapsed();
-    }
-    else if(m_file.endsWith(".FIT", Qt::CaseInsensitive) || m_file.endsWith(".FITS", Qt::CaseInsensitive))
-    {
-        loadFITS(m_file, info, &rawImage);
-        qDebug() << "LoadFITS" << timer.elapsed();
-    }
-    else if(m_file.endsWith(".XISF", Qt::CaseInsensitive))
-    {
-        loadXISF(m_file, info, &rawImage);
-        qDebug() << "LoadXISF" << timer.elapsed();
-    }
-    else
-    {
-        QImage img(m_file);
-#ifdef COLOR_MANAGMENT
-        if(img.colorSpace().isValid() && img.colorSpace() != QColorSpace::SRgb)
-            img.convertToColorSpace(QColorSpace::SRgb);
-#endif
-
-        ExifData *exif = exif_data_new_from_file(m_file.toLocal8Bit().constData());
-        info.info.append({QObject::tr("Width"), QString::number(img.width())});
-        info.info.append({QObject::tr("Height"), QString::number(img.height())});
-        if(exif)
         {
-            loadExifEntry(info, exif->ifd[EXIF_IFD_EXIF], EXIF_TAG_ISO_SPEED_RATINGS);
+            return;
-            loadExifEntry(info, exif->ifd[EXIF_IFD_EXIF], EXIF_TAG_SHUTTER_SPEED_VALUE);
-            exif_data_free(exif);
         }
-        rawImage = new RawImage(img);
+        QElapsedTimer timer;
-    }
+        ImageInfoData info;
+        QFileInfo finfo(m_file);
+        info.info.append({QObject::tr("Filename"), finfo.fileName()});
 
-    if(rawImage && m_analyzeLevel >= Statistics && !m_thumbnail)
+        RawImage *rawImage = nullptr;
-    {
+        bool raw = false;
-        double mean, median, min, max, mad;
-        double stdDev;
-        uint32_t saturated;
         timer.start();
-        rawImage->imageStats(&mean, &stdDev, &median, &min, &max, &mad, &saturated);
+        if(m_file.endsWith(".CR2", Qt::CaseInsensitive) || m_file.endsWith(".NEF", Qt::CaseInsensitive) || m_file.endsWith(".DNG", Qt::CaseInsensitive))
-        qDebug() << "image stats" << timer.restart();
-        info.info.append({QObject::tr("Mean"), QString::number(mean)});
-        info.info.append({QObject::tr("Standart deviation"), QString::number(stdDev)});
-        info.info.append({QObject::tr("Median"), QString::number(median)});
-        info.info.append({QObject::tr("Minimum"), QString::number(min)});
-        info.info.append({QObject::tr("Maximum"), QString::number(max)});
-        info.info.append({QObject::tr("MAD"), QString::number(mad)});
-        info.info.append({QObject::tr("Saturated"), QString::number(100.0 * saturated / rawImage->size()) + "%"});
-
-        if(m_analyzeLevel >= Peaks)
         {
-            std::vector<Peak> peaks;
+            loadRAW(m_file, info, &rawImage);
-            if(raw) {
+            raw = true;
-                rawImage->quarter();
+            qDebug() << "LoadRAW" << timer.elapsed();
-                qDebug() << "quarter" << timer.restart();
-            }
-            RawImage *medianImage = rawImage->medianFilter();
-            qDebug() << "median" << timer.restart();
-            int numPeaks = medianImage->findPeaks(median+stdDev*2, 20, peaks);
-            delete medianImage;
-            qDebug() << "peaks" << timer.restart();
-            //if(m_analyzeLevel == Peaks)
-            //    drawPeaks(img, peaks);
-            qDebug() << "draw peaks" << timer.restart();
-            info.info.append({QObject::tr("Peaks"), QString::number(numPeaks)});
-            //info.info.append({QObject::tr("Peaks draw"), QString::number(peaks.size())});
-
-            if(m_analyzeLevel>= Stars)
-            {
-                double fwhmX = 0;
-                double fwhmY = 0;
-                const int radius = 13;
-                StarFit starFit(radius);
-                std::vector<Star> stars;
-                for(uint i=0; i<peaks.size(); i++)
-                {
-                    Peak p = peaks[i];
-                    std::vector<double> r;
-                    int x = p.x();
-                    int y = p.y();
-                    rawImage->rect(x, y, radius, radius, r);
-                    Star star = starFit.fitStar(r, false);
-                    if(star.valid())
-                    {
-                        //printStarModel(radius, r, star);
-                        star.m_x += x;
-                        star.m_y += y;
-                        fwhmX += star.fwhmX();
-                        fwhmY += star.fwhmY();
-                        stars.push_back(star);
-                    }
-                }
-                //drawStars(img, stars);
-                info.info.append({QObject::tr("FWHM X"), QString::number(fwhmX/stars.size())});
-                info.info.append({QObject::tr("FWHM Y"), QString::number(fwhmY/stars.size())});
-            }
-            qDebug() << "Star fit" << timer.restart();
         }
-    }
+        else if(m_file.endsWith(".FIT", Qt::CaseInsensitive) || m_file.endsWith(".FITS", Qt::CaseInsensitive))
-
-    if(m_thumbnail)
-    {
-        if(rawImage)
         {
-            rawImage->convertToThumbnail();
+            loadFITS(m_file, info, &rawImage);
-            QMetaObject::invokeMethod(m_receiver, "thumbnailLoadFinish", Qt::QueuedConnection, Q_ARG(void*, rawImage));
+            qDebug() << "LoadFITS" << timer.elapsed();
+        }
+        else if(m_file.endsWith(".XISF", Qt::CaseInsensitive))
+        {
+            loadXISF(m_file, info, &rawImage);
+            qDebug() << "LoadXISF" << timer.elapsed();
         }
         else
         {
-            qDebug() << "failed";
+            QImage img(m_file);
+    #ifdef COLOR_MANAGMENT
+            if(img.colorSpace().isValid() && img.colorSpace() != QColorSpace::SRgb)
+                img.convertToColorSpace(QColorSpace::SRgb);
+    #endif
+
+            ExifData *exif = exif_data_new_from_file(m_file.toLocal8Bit().constData());
+            info.info.append({QObject::tr("Width"), QString::number(img.width())});
+            info.info.append({QObject::tr("Height"), QString::number(img.height())});
+            if(exif)
+            {
+                loadExifEntry(info, exif->ifd[EXIF_IFD_EXIF], EXIF_TAG_ISO_SPEED_RATINGS);
+                loadExifEntry(info, exif->ifd[EXIF_IFD_EXIF], EXIF_TAG_SHUTTER_SPEED_VALUE);
+                exif_data_free(exif);
+            }
+            rawImage = new RawImage(img);
         }
+
+        if(rawImage && m_analyzeLevel >= Statistics && !m_thumbnail)
+        {
+            double mean, median, min, max, mad;
+            double stdDev;
+            uint32_t saturated;
+            timer.start();
+            rawImage->imageStats(&mean, &stdDev, &median, &min, &max, &mad, &saturated);
+            qDebug() << "image stats" << timer.restart();
+            info.info.append({QObject::tr("Mean"), QString::number(mean)});
+            info.info.append({QObject::tr("Standart deviation"), QString::number(stdDev)});
+            info.info.append({QObject::tr("Median"), QString::number(median)});
+            info.info.append({QObject::tr("Minimum"), QString::number(min)});
+            info.info.append({QObject::tr("Maximum"), QString::number(max)});
+            info.info.append({QObject::tr("MAD"), QString::number(mad)});
+            info.info.append({QObject::tr("Saturated"), QString::number(100.0 * saturated / rawImage->size()) + "%"});
+
+            if(m_analyzeLevel >= Peaks)
+            {
+                std::vector<Peak> peaks;
+                if(raw) {
+                    rawImage->quarter();
+                    qDebug() << "quarter" << timer.restart();
+                }
+                RawImage *medianImage = rawImage->medianFilter();
+                qDebug() << "median" << timer.restart();
+                int numPeaks = medianImage->findPeaks(median+stdDev*2, 20, peaks);
+                delete medianImage;
+                qDebug() << "peaks" << timer.restart();
+                //if(m_analyzeLevel == Peaks)
+                //    drawPeaks(img, peaks);
+                qDebug() << "draw peaks" << timer.restart();
+                info.info.append({QObject::tr("Peaks"), QString::number(numPeaks)});
+                //info.info.append({QObject::tr("Peaks draw"), QString::number(peaks.size())});
+
+                if(m_analyzeLevel>= Stars)
+                {
+                    double fwhmX = 0;
+                    double fwhmY = 0;
+                    const int radius = 13;
+                    StarFit starFit(radius);
+                    std::vector<Star> stars;
+                    for(uint i=0; i<peaks.size(); i++)
+                    {
+                        Peak p = peaks[i];
+                        std::vector<double> r;
+                        int x = p.x();
+                        int y = p.y();
+                        rawImage->rect(x, y, radius, radius, r);
+                        Star star = starFit.fitStar(r, false);
+                        if(star.valid())
+                        {
+                            //printStarModel(radius, r, star);
+                            star.m_x += x;
+                            star.m_y += y;
+                            fwhmX += star.fwhmX();
+                            fwhmY += star.fwhmY();
+                            stars.push_back(star);
+                        }
+                    }
+                    //drawStars(img, stars);
+                    info.info.append({QObject::tr("FWHM X"), QString::number(fwhmX/stars.size())});
+                    info.info.append({QObject::tr("FWHM Y"), QString::number(fwhmY/stars.size())});
+                }
+                qDebug() << "Star fit" << timer.restart();
+            }
+        }
+
+        if(m_thumbnail)
+        {
+            if(rawImage)
+            {
+                rawImage->convertToThumbnail();
+                QMetaObject::invokeMethod(m_receiver, "thumbnailLoadFinish", Qt::QueuedConnection, Q_ARG(void*, rawImage));
+            }
+        }
+        else
+            QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(void*, rawImage), Q_ARG(ImageInfoData, info));
+    }
+    catch(cv::Exception e)
+    {
+        qDebug() << e.what();
+    }
+    catch(std::exception e)
+    {
+       qDebug() << e.what();
     }
-    else
-        QMetaObject::invokeMethod(m_receiver, "imageLoaded", Qt::QueuedConnection, Q_ARG(void*, rawImage), Q_ARG(ImageInfoData, info));
 }
 
 bool readFITSHeader(const QString &path, ImageInfoData &info)

rawimage.cpp

@@ -224,10 +224,13 @@ int RawImage::findPeaks(double background, double distance, std::vector<Peak> &p
 
     cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(distance, distance));
 
-    cv::Mat mask, dilate, locMax, result;
+    cv::Mat img, mask, dilate, locMax, result;
-    cv::dilate(m_img, dilate, kernel);
+    if(m_img.channels() == 1)img = m_img;
-    cv::compare(m_img, dilate, locMax, cv::CMP_GE);
+    else cv::cvtColor(m_img, img, cv::COLOR_RGB2GRAY);
-    cv::compare(m_img, cv::Scalar(background), mask, cv::CMP_GT);
+
+    cv::dilate(img, dilate, kernel);
+    cv::compare(img, dilate, locMax, cv::CMP_GE);
+    cv::compare(img, cv::Scalar(background), mask, cv::CMP_GT);
     cv::bitwise_and(locMax, mask, result);
 
     cv::findContours(result, contours, cv::noArray(), cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

starfit.cpp

@@ -237,6 +237,8 @@ StarFit::StarFit(int size)
     m_fdf_an.fvv = nullptr;
     m_fdf_an.n = size*size;
     m_fdf_an.p = 6;//number of model parameters amplitude, x, y, sigma_x, sigma_y, angle
+
+    gsl_set_error_handler_off();
 }
 
 StarFit::~StarFit()
@@ -272,14 +274,10 @@ Star StarFit::fitStar(const std::vector<double> &data, bool angle)
 
     gsl_multifit_nlinear_workspace *workspace = gsl_multifit_nlinear_alloc(gsl_multifit_nlinear_trust, &m_fdf_params, fdf->n, fdf->p);
 
-    gsl_multifit_nlinear_init(start, fdf, workspace);
+    int ret = gsl_multifit_nlinear_init(start, fdf, workspace);
-    gsl_vector *f = gsl_multifit_nlinear_residual(workspace);
+    if(ret)return star;
 
-    double cost, cost0;
+    ret = gsl_multifit_nlinear_driver(MAX_ITER, TOL, TOL, TOL, nullptr, nullptr, &info, workspace);
-    gsl_blas_ddot(f, f, &cost0);
-    int ret = gsl_multifit_nlinear_driver(MAX_ITER, TOL, TOL, TOL, nullptr, nullptr, &info, workspace);
-
-    gsl_blas_ddot(f, f, &cost);
 
     if(ret==0)
     {