HPPA/HPPA/focusWindow.h

#pragma once

#include "windows.h"
#include <cstdio>
#include <iostream>
#include <exception>
#include <stdexcept>
#include <cmath>
#include <io.h>

#include <QtWidgets/QMainWindow>
#include <QThread>
#include <QLineSeries>
#include <QChart>
#include <QChartView>
#include <QFileDialog>
#include <QtSerialPort/QSerialPort>
#include <QtSerialPort/QSerialPortInfo>
#include <QDateTime>
#include <QMutex>
#include <QPointer>

#include "ui_FocusDialog.h"
#include "AbstractPortMiscDefines.h"
#include "CFocusMotorControl.h"

#include "resononImager.h"

#include "hppaConfigFile.h"
#include "path_tc.h"
#include "ImagerOperationBase.h"
#include "IrisMultiMotorController.h"

#include <Eigen/Dense>
#include <cmath>

// 数据记录结构体
struct PositionData {
	double targetPosition;    // 目标位置
	double actualPosition; // 实际马达位置
	double cameraIndex;    // 相机采集指数
	QDateTime timestamp;   // 时间戳

	PositionData(double target = 0, double actual = 0.0, double index = 0.0)
		: targetPosition(target), actualPosition(actual),
		cameraIndex(index), timestamp(QDateTime::currentDateTime()) {}
};

// 协调控制器
class MotionCaptureCoordinator : public QObject
{
	Q_OBJECT
public:
	MotionCaptureCoordinator(IrisMultiMotorController* motorCtrl,
		ImagerOperationBase* cameraCtrl,
		QObject* parent = nullptr);
	~MotionCaptureCoordinator();

	QVector<PositionData> getAllPositionData() const;
	bool saveToCsv(const QString& filename);

public slots:
	void startStepMotion(double speed, int stepInterval = 100, double startPos = 0, double endPos = -1);//-1：马达能到达的最远位置
	void stopStepMotion();

signals:
	void progressChanged(int progress);
	void sequenceComplete();
	void sequenceStopped();
	void errorOccurred(const QString& error);
	void moveTo(int, double, double, int);
	void getFocusIndexSobel();
	void zeroStart(int motorID);

private slots:
	void handlePositionReached(int motorID, double pos);
	void handleCaptureComplete(double index);
	void handleError(const QString& error);
	void handleZeroComplete(int motorID, double pos);

private:
	void processNextPosition();
	void startMotionSequence();

	IrisMultiMotorController* m_motorCtrl;
	ImagerOperationBase* m_cameraCtrl;
	QVector<PositionData> m_positionData;
	mutable QMutex m_dataMutex;

	double m_posInternal;
	double m_currentPos;
	double m_startPos;
	double m_endPos;
	bool m_isRunning;
	double m_speed;

	int m_iStepInterval;
	int m_iStepIntervalRealTime;
	int m_counter;
	bool m_isZeroing;
};

class focusWindow:public QDialog
{
	Q_OBJECT

public:
	focusWindow(QWidget *parent = Q_NULLPTR);
	focusWindow(QWidget *parent, ImagerOperationBase* imager);
	~focusWindow();

	ImagerOperationBase* m_Imager;

	void setIsDisplaysAutofocusResultViaPopup(bool isDisplaysAutofocusResultViaPopup);

protected:
	bool eventFilter(QObject *obj, QEvent *event) override;

private:
	QPoint m_dragPosition;
	bool m_bDrag = false;

	Ui::focusDialog ui;
	QThread *m_AutoFocusThread;
	int m_FocusState;

	int m_iMinPos, m_iMaxPos;
	
	CFocusMotorControl* m_ctrlFocusMotor;

	void disableBeforeConnect(bool disable);

	QThread m_motorThread;
	QPointer<IrisMultiMotorController> m_multiAxisController;
	double m_dSpeed;

	QThread m_MotionCaptureCoordinatorThread;
	QPointer<MotionCaptureCoordinator> m_coordinator;

	int m_iStepSize;
	double m_goodPos;
	bool m_isAutoFocusSuccess;
	bool m_isMoveAfterAutoFocus = false;
	int m_moveRetryCount = 0;
	static constexpr int MAX_MOVE_RETRY = 3;
	void getGaussianInitParam(const std::vector<double>& pos, const std::vector<double>& index, double& a_init, double& mu_init, double& sigma_init, double& c_init);
	void gaussian_fit(const std::vector<double>& x_data, const std::vector<double>& y_data, double& a, double& mu, double& sigma, double& c);

	bool m_xMotorConnectionStatus = false;
	bool getMotorsConnectionStatus();
	void connectMotor(bool isNotification);

	void showMessageBox(QString msg, QString title = QString::fromLocal8Bit("提示"));
	
	double getErrorRate(double targetLoc, double actualLoc);

	bool m_isDisplaysAutofocusResultViaPopup = true;

public Q_SLOTS:
	void onConnectMotor();
	void onMove2MotorLogicZero();
	void onMove2MotorMax();
	void onAdd();
	void onSubtract();
	void onAutoFocus();
	void onManualFocus();
	void onUpdateCurrentLocation();
	void onMoveto();
	void onAutoFocusFinished();
	void onAutoFocusProgress(int progress);
	void onUltrasound_radioButton();

	void display_x_loc(std::vector<double> loc);
	void onx_rangeMeasurement();

	void moveAfterAutoFocus(int motorID, double location);

	void onExit();

	void display_motors_connectivity(std::vector<int> connectivity);

signals:
	void StartManualFocusSignal(int);//1：开始调焦；0：停止调焦；

	void move2LocSignal(int, double, double, int);
	void move2MaxLocSignal(int, double, int);
	void rmoveSignal(int, double, double, int);
	void rangeMeasurementSignal(int, double, int);
	void zeroStartSignal(int);
	void testConnectivitySignal(int, int);

	void startStepMotionSignal(double speed, int stepInterval = 100, double startPos = 0, double endPos = -1);
	void closeSignal();

	void AutoFocusFinishedSignal(int status);
};

class WorkerThread2 : public QThread
{
	Q_OBJECT
private:
	bool m_bIsUltrasound;

public:
	WorkerThread2(CFocusMotorControl * ctrlFocusMotor,bool isUltrasound);
	CFocusMotorControl *m_ctrlFocusMotor;

protected:
	void run();

signals:
	void AutoFocusFinishedSignal();
};

class WorkerThread4 : public QThread
{
	Q_OBJECT
private:

public:
	WorkerThread4(CFocusMotorControl * ctrlFocusMotor);
	CFocusMotorControl *m_ctrlFocusMotor;

protected:
	void run();

signals:
	void AutoFocusProgressSignal(int);
};