Differential D29325 Diff 81867 kstars/fitsviewer/fitsdata.cpp

Changeset View

Standalone View

View Options

kstars/fitsviewer/fitsdata.cpp

Show All 12 Lines
13 * the Free Software Foundation; either version 2 of the License, or * 13​ * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. * 14​ * (at your option) any later version. *
15 * * 15​ * *
16 * Some code fragments were adapted from Peter Kirchgessner's FITS plugin* 16​ * Some code fragments were adapted from Peter Kirchgessner's FITS plugin*
17 * See http://members.aol.com/pkirchg for more details. * 17​ * See http://members.aol.com/pkirchg for more details. *
18 ***************************************************************************/ 18​ ***************************************************************************/
19 19​
20#include "fitsdata.h" 20​#include "fitsdata.h"
21​#include "fitsbahtinovdetector.h"
21#include "fitsthresholddetector.h" 22​#include "fitsthresholddetector.h"
22#include "fitsgradientdetector.h" 23​#include "fitsgradientdetector.h"
23#include "fitscentroiddetector.h" 24​#include "fitscentroiddetector.h"
24#include "fitssepdetector.h" 25​#include "fitssepdetector.h"
25 26​
26#include "fpack.h" 27​#include "fpack.h"
27 28​
28#include "kstarsdata.h" 29​#include "kstarsdata.h"
▲ Show 20 Lines • Show All 766 Lines • ▼ Show 20 Line(s)764 {
795 796​
796 double variance = squared_sum / stats.samples_per_channel; 797​ double variance = squared_sum / stats.samples_per_channel;
797 798​
798 stats.mean[n] = mean / nThreads; 799​ stats.mean[n] = mean / nThreads;
799 stats.stddev[n] = sqrt(variance); 800​ stats.stddev[n] = sqrt(variance);
800 } 801​ }
801} 802​}
802 803​
804​QVector<double> FITSData::createGaussianKernel(int size, double sigma)
805​{
806​ QVector<double> kernel(size * size);
807​ kernel.fill(0.0, size * size);
808​
809​ double kernelSum = 0.0;
810​ int fOff = (size - 1) / 2;
811​ double normal = 1.0 / (2.0 * M_PI * sigma * sigma);
812​ for (int y = -fOff; y <= fOff; y++) {
813​ for (int x = -fOff; x <= fOff; x++) {
814​ double distance = ((y * y) + (x * x)) / (2.0 * sigma * sigma);
815​ int index = (y + fOff) * size + (x + fOff);
816​ kernel[index] = normal * qExp(-distance);
817​ kernelSum += kernel.at(index);
818​ }
819​ }
820​ for (int y = 0; y < size; y++) {
821​ for (int x = 0; x < size; x++) {
822​ int index = y * size + x;
823​ kernel[index] = kernel.at(index) * 1.0 / kernelSum;
824​ }
825​ }
826​
827​ return kernel;
828​}
829​
830​template <typename T>
831​void FITSData::convolutionFilter(const QVector<double> &kernel, int kernelSize)
832​{
833​ T * imagePtr = reinterpret_cast<T *>(m_ImageBuffer);
834​
835​ // Create variable for pixel data for each kernel
836​ T gt = 0;
837​
838​ // This is how much your center pixel is offset from the border of your kernel
839​ int fOff = (kernelSize - 1) / 2;
840​
841​ // Start with the pixel that is offset fOff from top and fOff from the left side
842​ // this is so entire kernel is on your image
843​ for (int offsetY = 0; offsetY < stats.height; offsetY++)
844​ {
845​ for (int offsetX = 0; offsetX < stats.width; offsetX++)
846​ {
847​ // reset gray value to 0
848​ gt = 0;
849​ // position of the kernel center pixel
850​ int byteOffset = offsetY * stats.width + offsetX;
851​
852​ // kernel calculations
853​ for (int filterY = -fOff; filterY <= fOff; filterY++)
854​ {
855​ for (int filterX = -fOff; filterX <= fOff; filterX++)
856​ {
857​ if ((offsetY + filterY) >= 0 && (offsetY + filterY) < stats.height
858​ && ((offsetX + filterX) >= 0 && (offsetX + filterX) < stats.width ))
859​ {
860​
861​ int calcOffset = byteOffset + filterX + filterY * stats.width;
862​ int index = (filterY + fOff) * kernelSize + (filterX + fOff);
863​ double kernelValue = kernel.at(index);
864​ gt += (imagePtr[calcOffset]) * kernelValue;
865​ }
866​ }
867​ }
868​
869​ // set new data in the other byte array for your image data
870​ imagePtr[byteOffset] = gt;
871​ }
872​ }
873​}
874​
875​template <typename T>
876​void FITSData::gaussianBlur(int kernelSize, double sigma)
877​{
878​ // Size must be an odd number!
879​ if (kernelSize % 2 == 0)
880​ {
881​ kernelSize--;
882​ qCInfo(KSTARS_FITS) << "Warning, size must be an odd number, correcting size to " << kernelSize;
883​ }
884​ // Edge must be a positive number!
885​ if (kernelSize < 1)
886​ {
887​ kernelSize = 1;
888​ }
889​
890​ QVector<double> gaussianKernel = createGaussianKernel(kernelSize, sigma);
891​ convolutionFilter<T>(gaussianKernel, kernelSize);
892​}
893​
803void FITSData::setMinMax(double newMin, double newMax, uint8_t channel) 894​void FITSData::setMinMax(double newMin, double newMax, uint8_t channel)
804{ 895​{
805 stats.min[channel] = newMin; 896​ stats.min[channel] = newMin;
806 stats.max[channel] = newMax; 897​ stats.max[channel] = newMax;
807} 898​}
808 899​
809bool FITSData::parseHeader() 900​bool FITSData::parseHeader()
810{ 901​{
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Line(s)
913#endif 1004​#endif
914 break; 1005​ break;
915 1006​
916 case ALGORITHM_THRESHOLD: 1007​ case ALGORITHM_THRESHOLD:
917 count = FITSThresholdDetector(this) 1008​ count = FITSThresholdDetector(this)
918 .configure("THRESHOLD_PERCENTAGE", Options::focusThreshold()) 1009​ .configure("THRESHOLD_PERCENTAGE", Options::focusThreshold())
919 .findSources(starCenters, trackingBox); 1010​ .findSources(starCenters, trackingBox);
920 break; 1011​ break;
1012​
1013​ case ALGORITHM_BAHTINOV:
1014​ count = FITSBahtinovDetector(this)
1015​ .configure("NUMBER_OF_AVERAGE_ROWS", Options::focusMultiRowAverage())
1016​ .findSources(starCenters, trackingBox);
1017​ break;
921 } 1018​ }
922 1019​
923 starsSearched = true; 1020​ starsSearched = true;
924 1021​
925 return count; 1022​ return count;
926} 1023​}
927 1024​
928int FITSData::filterStars(const float innerRadius, const float outerRadius) 1025​int FITSData::filterStars(const float innerRadius, const float outerRadius)
▲ Show 20 Lines • Show All 494 Lines • ▼ Show 20 Line(s)1463 {
1423 // Free memory 1520​ // Free memory
1424 delete[] extension; 1521​ delete[] extension;
1425 1522​
1426 if (calcStats) 1523​ if (calcStats)
1427 runningAverageStdDev<T>(); 1524​ runningAverageStdDev<T>();
1428 } 1525​ }
1429 break; 1526​ break;
1430 1527​
1528​ case FITS_GAUSSIAN:
1529​ gaussianBlur<T>(Options::focusGaussianKernelSize(), Options::focusGaussianSigma());
1530​ if (calcStats)
1531​ calculateStats(true);
1532​ break;
1533​
1431 case FITS_ROTATE_CW: 1534​ case FITS_ROTATE_CW:
1432 rotFITS<T>(90, 0); 1535​ rotFITS<T>(90, 0);
1433 rotCounter++; 1536​ rotCounter++;
1434 break; 1537​ break;
1435 1538​
1436 case FITS_ROTATE_CCW: 1539​ case FITS_ROTATE_CCW:
1437 rotFITS<T>(270, 0); 1540​ rotFITS<T>(270, 0);
1438 rotCounter--; 1541​ rotCounter--;
▲ Show 20 Lines • Show All 1753 Lines • Show Last 20 Lines