diff --git a/.gitignore b/.gitignore
index 6c9819f8..da459e01 100644
--- a/.gitignore
+++ b/.gitignore
@@ -114,6 +114,7 @@ Src4/nmNum/nmXml/*
!3rd/Pebi/**
!3rd/SinglePhaseSolver/**
!3rd/VTK7.1/**
+!3rd/FFmpeg-1.1/**
ML/nmWTAI-ML/.idea
ML/nmWTAI-ML/.venv
diff --git a/Bin/Config/Lang/cn/nmNum_cn.qm b/Bin/Config/Lang/cn/nmNum_cn.qm
index 08e3a20f..22eb17ab 100644
Binary files a/Bin/Config/Lang/cn/nmNum_cn.qm and b/Bin/Config/Lang/cn/nmNum_cn.qm differ
diff --git a/Bin/Config/Lang/cn/nmNum_cn.ts b/Bin/Config/Lang/cn/nmNum_cn.ts
index 07006ac0..326c447e 100644
--- a/Bin/Config/Lang/cn/nmNum_cn.ts
+++ b/Bin/Config/Lang/cn/nmNum_cn.ts
@@ -2838,6 +2838,67 @@ Reason: %1
The selected result frame is unavailable.所选结果帧不可用。
Playback speed must be a positive integer.播放速度必须为正整数。
+
+ nmFFmpegVideoWriter
+ Unknown FFmpeg error.未知的 FFmpeg 错误。
+ Unable to write the encoded video packet: %1无法写入已编码的视频数据包:%1
+ Unable to flush the video encoder: %1无法刷新视频编码器:%1
+ The video encoder settings are invalid.视频编码参数无效。
+ The video encoding components are unavailable.视频编码组件不可用。
+ Unable to initialize the video container.无法初始化视频容器。
+ Unable to create the video stream.无法创建视频流。
+ Unable to open the video encoder: %1无法打开视频编码器:%1
+ Unable to allocate the video frame buffer.无法分配视频帧缓冲区。
+ Unable to initialize the video color conversion.无法初始化视频颜色转换。
+ Unable to create the temporary video file.无法创建临时视频文件。
+ Unable to initialize the video file output.无法初始化视频文件输出。
+ Unable to write the video header: %1无法写入视频文件头:%1
+ The RGB video frame is invalid.RGB 视频帧无效。
+ Unable to convert the video frame colors.无法转换视频帧颜色。
+ Unable to encode the video frame: %1无法编码视频帧:%1
+ The video writer is not open.视频写入器尚未打开。
+ Unable to finalize the video container: %1无法完成视频容器写入:%1
+ Unable to flush the video output: %1无法刷新视频输出:%1
+ Unable to flush the temporary video file.无法刷新临时视频文件。
+ The temporary video file is empty.临时视频文件为空。
+ The FFmpeg runtime is incompatible. Expected avformat/avcodec/avutil/swscale major versions 54/54/52/2, but found %1/%2/%3/%4.FFmpeg 运行库不兼容。要求 avformat/avcodec/avutil/swscale 主版本为 54/54/52/2,实际为 %1/%2/%3/%4。
+ Video format .%1 is unavailable because muxer "%2" is missing.视频格式 .%1 不可用:缺少封装器“%2”。
+ Video format .%1 is unavailable because encoder "%2" is missing.视频格式 .%1 不可用:缺少编码器“%2”。
+ Video format .%1 is unavailable because muxer "%2" does not support codec "%3".视频格式 .%1 不可用:封装器“%2”不支持编码“%3”。
+
+
+ nmPebiResultAnimationExporter
+ The animation export request is invalid.动画导出请求无效。
+ The selected video format is unsupported.不支持所选视频格式。
+ Unable to prepare the animation result data.无法准备动画结果数据。
+ The animation render data failed validation.动画渲染数据校验失败。
+ Unable to create the animation mesh layer.无法创建动画网格图层。
+ Unable to create the animation scalar bar.无法创建动画色标。
+ Unable to create the animation scale grid.无法创建动画比例网格。
+ Unable to create the animation well annotations.无法创建动画井标注。
+ Unable to load an animation frame.无法加载动画帧。
+ Unable to capture an animation frame.无法截取动画帧。
+ Unable to publish the completed video file.无法发布已完成的视频文件。
+ The original file backup was retained at "%1".原文件备份已保留在“%1”。
+
+
+ nmWxPebiResultAnimationExportDlg
+ Export Animation导出动画
+ Frame rate帧率
+ FPS FPS
+ Start frame起始帧
+ End frame结束帧
+ Sampling interval采样间隔
+ Resolution分辨率
+ Current view当前视口
+ Custom自定义
+ Output size输出尺寸
+ Output frames输出帧数
+ Estimated duration预计时长
+ %1 h%1 h
+ %1 s%1 秒
+ The animation export settings are invalid.动画导出参数无效。
+
nmWxPebiResultControlBar
Property属性
@@ -2851,6 +2912,7 @@ Reason: %1
Play播放
Pause暂停
Animation settings动画设置
+ Export animation导出动画
t = %1 ht = %1 h
@@ -2894,6 +2956,28 @@ Reason: %1
Unable to display the latest result.无法显示最新结果。
Unable to display the latest result: %1无法显示最新结果:%1
Current inputs have changed. Showing the last successful result.当前输入已修改,正在显示上一次成功求解的结果。
+ Export Animation导出动画
+ Another result animation export is already in progress.已有结果动画正在导出。
+ Unable to read the result animation timeline.无法读取结果动画时间轴。
+ Save Result Animation保存结果动画
+ MP4 Video (*.mp4)MP4 视频 (*.mp4)
+ AVI Video (*.avi)AVI 视频 (*.avi)
+ QuickTime Video (*.mov)QuickTime 视频 (*.mov)
+ MPEG Video (*.mpg)MPEG 视频 (*.mpg)
+ WebM Video (*.webm)WebM 视频 (*.webm)
+ Matroska Video (*.mkv)Matroska 视频 (*.mkv)
+ Windows Media Video (*.wmv)Windows Media 视频 (*.wmv)
+ Flash Video (*.flv)Flash 视频 (*.flv)
+ The selected video file extension is unsupported.不支持所选视频文件扩展名。
+ The selected file already exists. Replace it?所选文件已存在,是否替换?
+ The displayed result changed before export started.开始导出前,当前显示结果已发生变化。
+ Unable to freeze the current result display.无法冻结当前结果显示状态。
+ Exporting result animation...正在导出结果动画...
+ Cancel取消
+ The result animation was saved to:
+%1结果动画已保存到:
+%1
+ Unable to export the result animation.无法导出结果动画。
nmWxPebiGridViewWidget
diff --git a/Include/nmNum/nmSubWxs/nmFFmpegVideoWriter.h b/Include/nmNum/nmSubWxs/nmFFmpegVideoWriter.h
new file mode 100644
index 00000000..ec6199c5
--- /dev/null
+++ b/Include/nmNum/nmSubWxs/nmFFmpegVideoWriter.h
@@ -0,0 +1,89 @@
+#ifndef NMFFMPEGVIDEOWRITER_H
+#define NMFFMPEGVIDEOWRITER_H
+
+#include "nmSubWxs_global.h"
+
+#include
+#include
+
+/** @brief 使用项目固定FFmpeg 1.1 DLL编码RGB24视频。 */
+class NM_SUB_WXS_EXPORT nmFFmpegVideoWriter
+{
+public:
+ /** @brief 打开视频编码器所需的规范化参数。 */
+ struct VideoSettings
+ {
+ /** @brief 创建尚未指定文件、尺寸和帧率的空参数。 */
+ VideoSettings();
+
+ /** @brief Writer规范为绝对路径后写入,并在失败或取消时删除的临时文件。 */
+ QString m_sTemporaryFilePath;
+ /** @brief 决定固定容器和编码器组合的扩展名,可带或不带点号。 */
+ QString m_sFileExtension;
+ /** @brief 输出宽度,单位为像素,必须是2~8192之间的偶数。 */
+ int m_nWidth;
+ /** @brief 输出高度,单位为像素,必须是2~8192之间的偶数。 */
+ int m_nHeight;
+ /** @brief 视频帧率,正式有效范围为1~5000 FPS。 */
+ int m_nFramesPerSecond;
+ };
+
+ /** @brief 创建尚未打开编码会话的Writer。 */
+ nmFFmpegVideoWriter();
+ /** @brief 析构Writer;仍在编码时按取消路径清理临时文件。 */
+ ~nmFFmpegVideoWriter();
+
+ /**
+ * @brief 创建编码器并打开临时文件;失败时不会留下半成品。
+ * @param oSettings 已规范化的视频参数。
+ * @param pError 可选错误输出;进入函数后先清空。
+ * @return 编码器、容器和自定义文件IO全部初始化成功时返回true。
+ */
+ bool open(const VideoSettings& oSettings, QString* pError = nullptr);
+
+ /**
+ * @brief 写入一帧RGB24数据,stride允许包含行尾填充。
+ * @param pData 输入帧首地址,只在本次调用期间读取。
+ * @param nStride 每行字节数,不得小于宽度乘3。
+ * @param bBottomUp 为true时首地址对应图像底行,Writer负责垂直翻转。
+ * @param pError 可选错误输出;进入函数后先清空。
+ * @return 完整帧成功交给编码器和Muxer时返回true。
+ */
+ bool writeRgb24Frame(const unsigned char* pData,
+ int nStride,
+ bool bBottomUp,
+ QString* pError = nullptr);
+
+ /**
+ * @brief 刷新编码器并写完容器;成功后临时文件才可发布。
+ * @param pError 可选错误输出;进入函数后先清空。
+ * @return Trailer、IO刷新和非空文件校验全部成功时返回true。
+ */
+ bool finish(QString* pError = nullptr);
+
+ /** @brief 中止编码并删除Writer拥有的临时文件。 */
+ void cancel();
+
+ /**
+ * @brief 校验固定DLL主版本及全部正式格式组合是否可用。
+ * @param pError 可选错误输出;失败时说明具体版本、格式或组件。
+ * @return 八种正式格式全部可用时返回true。
+ */
+ static bool isBackendAvailable(QString* pError = nullptr);
+
+ /** @brief 返回正式支持的八种文件扩展名,均不包含点号。 */
+ static QStringList getSupportedExtensions();
+
+ /** @brief 判断扩展名是否属于正式格式,比较时忽略大小写和前导点号。 */
+ static bool isSupportedExtension(const QString& sExtension);
+
+private:
+ Q_DISABLE_COPY(nmFFmpegVideoWriter)
+
+ /** @brief 隔离FFmpeg头文件和编码资源的私有实现。 */
+ class Private;
+ /** @brief Writer独占的状态、FFmpeg对象及临时文件资源。 */
+ Private* m_pPrivate;
+};
+
+#endif // NMFFMPEGVIDEOWRITER_H
diff --git a/Include/nmNum/nmSubWxs/nmPebiResultAnimationExportSettings.h b/Include/nmNum/nmSubWxs/nmPebiResultAnimationExportSettings.h
new file mode 100644
index 00000000..d9b57276
--- /dev/null
+++ b/Include/nmNum/nmSubWxs/nmPebiResultAnimationExportSettings.h
@@ -0,0 +1,45 @@
+#ifndef NMPEBIRESULTANIMATIONEXPORTSETTINGS_H
+#define NMPEBIRESULTANIMATIONEXPORTSETTINGS_H
+
+#include "nmSubWxs_global.h"
+
+#include
+
+/** @brief PEBI结果动画导出的已规范化纯值参数。 */
+class NM_SUB_WXS_EXPORT nmPebiResultAnimationExportSettings
+{
+public:
+ /** @brief 创建默认15 FPS、单帧范围、采样间隔1和2x2输出参数。 */
+ nmPebiResultAnimationExportSettings();
+
+ /**
+ * @brief 校验帧范围、采样间隔、帧率及输出尺寸是否可用于导出。
+ * @param nAvailableFrameCount 当前动态属性可用的总帧数。
+ * @return 全部参数有效时返回true。
+ */
+ bool isValid(int nAvailableFrameCount) const;
+
+ /**
+ * @brief 按闭区间和采样间隔生成零基帧下标,并保证包含结束帧。
+ * @return 有效的有序帧下标;基础范围无效时返回空数组。
+ */
+ QVector buildFrameIndices() const;
+
+ /** @brief 返回buildFrameIndices()生成的实际输出帧数。 */
+ int getOutputFrameCount() const;
+
+ /** @brief 视频帧率,正式有效范围为1~5000 FPS。 */
+ int m_nFramesPerSecond;
+ /** @brief 导出闭区间的零基起始帧下标。 */
+ int m_nStartFrameIndex;
+ /** @brief 导出闭区间的零基结束帧下标,允许与起始帧相同。 */
+ int m_nEndFrameIndex;
+ /** @brief 原始结果帧的正整数采样间隔。 */
+ int m_nSamplingInterval;
+ /** @brief 输出宽度,单位为像素,必须是2~8192之间的偶数。 */
+ int m_nOutputWidth;
+ /** @brief 输出高度,单位为像素,必须是2~8192之间的偶数。 */
+ int m_nOutputHeight;
+};
+
+#endif // NMPEBIRESULTANIMATIONEXPORTSETTINGS_H
diff --git a/Include/nmNum/nmSubWxs/nmPebiResultAnimationExporter.h b/Include/nmNum/nmSubWxs/nmPebiResultAnimationExporter.h
new file mode 100644
index 00000000..08c5fc9d
--- /dev/null
+++ b/Include/nmNum/nmSubWxs/nmPebiResultAnimationExporter.h
@@ -0,0 +1,94 @@
+#ifndef NMPEBIRESULTANIMATIONEXPORTER_H
+#define NMPEBIRESULTANIMATIONEXPORTER_H
+
+#include "nmSubWxs_global.h"
+#include "nmPebiResultAnimationExportSettings.h"
+#include "nmPebiResultDisplaySettings.h"
+
+#include
+#include
+#include
+#include
+
+class nmPebiResultSnapshot;
+class vtkCamera;
+
+/** @brief 在独立VTK场景中同步渲染并编码PEBI结果动画。 */
+class NM_SUB_WXS_EXPORT nmPebiResultAnimationExporter : public QObject
+{
+ Q_OBJECT
+
+public:
+ /** @brief 一次同步导出调用的终止状态。 */
+ enum ExportResult
+ {
+ /** 临时视频已成功发布到目标路径。 */
+ Export_Succeeded = 0,
+ /** 用户在完整帧边界请求取消,临时文件已清理。 */
+ Export_Cancelled,
+ /** 渲染、编码或文件发布失败,详细原因由pError返回。 */
+ Export_Failed
+ };
+
+ /** @brief 调用方在开始导出前冻结的全部输入。 */
+ struct Request
+ {
+ /** @brief 创建空请求,显隐和背景字段使用默认值。 */
+ Request();
+
+ /** @brief 导出期间持有的只读快照强引用。 */
+ QSharedPointer m_pSnapshot;
+ /** @brief 待导出的稳定动态属性ID。 */
+ QString m_sPropertyId;
+ /** @brief 开始导出时冻结的颜色映射设置。 */
+ nmPebiResultDisplaySettings m_oDisplaySettings;
+ /** @brief 已规范化的帧范围、采样、帧率和输出尺寸。 */
+ nmPebiResultAnimationExportSettings m_oExportSettings;
+ /** @brief 最终视频目标路径,扩展名决定输出格式。 */
+ QString m_sTargetFilePath;
+ /** @brief 是否在视频中显示色标。 */
+ bool m_bScalarBarVisible;
+ /** @brief 是否在视频中显示比例网格。 */
+ bool m_bScaleGridVisible;
+ /** @brief 是否在视频中显示井名和引线。 */
+ bool m_bWellNamesVisible;
+ /** @brief Renderer第一背景色,三个分量均为0~1。 */
+ double m_dBackground[3];
+ /** @brief Renderer渐变背景的第二颜色,三个分量均为0~1。 */
+ double m_dBackground2[3];
+ /** @brief 是否启用Renderer渐变背景。 */
+ bool m_bGradientBackground;
+ /** @brief 当前屏幕相机的深拷贝,导出器不会修改屏幕相机。 */
+ vtkSmartPointer m_pCamera;
+ };
+
+ /** @param pParent Qt父对象,不参与VTK资源所有权。 */
+ explicit nmPebiResultAnimationExporter(QObject* pParent = nullptr);
+ /** @brief 释放导出器;实际导出在exportAnimation()返回前同步结束。 */
+ virtual ~nmPebiResultAnimationExporter();
+
+ /**
+ * @brief 同步执行离屏渲染、临时编码和最终文件发布事务。
+ * @param oRequest 调用期间保持不变的冻结请求。
+ * @param pError 可选错误输出;取消不写入错误文字。
+ * @return 成功、取消或失败状态。
+ */
+ ExportResult exportAnimation(const Request& oRequest,
+ QString* pError = nullptr);
+
+signals:
+ /** @brief 每完成一帧编码后报告进度,首次以0作为已完成帧数。 */
+ void progressChanged(int nCompletedFrames, int nTotalFrames);
+
+public slots:
+ /** @brief 请求在当前完整帧写入后取消;不会中断正在编码的半帧。 */
+ void cancel();
+
+private:
+ Q_DISABLE_COPY(nmPebiResultAnimationExporter)
+
+ /** @brief 在完整帧编码边界读取的取消请求标志。 */
+ bool m_bCancelRequested;
+};
+
+#endif // NMPEBIRESULTANIMATIONEXPORTER_H
diff --git a/Include/nmNum/nmSubWxs/nmPebiResultDisplayStateBuilder.h b/Include/nmNum/nmSubWxs/nmPebiResultDisplayStateBuilder.h
new file mode 100644
index 00000000..c5754b08
--- /dev/null
+++ b/Include/nmNum/nmSubWxs/nmPebiResultDisplayStateBuilder.h
@@ -0,0 +1,59 @@
+#ifndef NMPEBIRESULTDISPLAYSTATEBUILDER_H
+#define NMPEBIRESULTDISPLAYSTATEBUILDER_H
+
+#include "nmPebiResultDisplaySettings.h"
+
+#include
+#include
+#include
+#include
+
+class nmPebiResultSnapshot;
+/** @brief 屏幕场景和离屏导出共同使用的完整属性显示状态。 */
+struct nmPebiResultDisplayState
+{
+ /** @brief 创建不持有LUT的空显示状态。 */
+ nmPebiResultDisplayState();
+
+ /** @brief 经过normalized()处理并实际用于构造状态的设置。 */
+ nmPebiResultDisplaySettings m_oSettings;
+ /** @brief 快照中的真实属性范围,不受手工显示范围影响。 */
+ double m_dBusinessRange[2];
+ /** @brief 色标和设置界面对外显示的范围。 */
+ double m_dVisibleRange[2];
+ /** @brief LUT实际范围;单值模式下为满足VTK要求进行微量扩展。 */
+ double m_dInternalRange[2];
+ /** @brief 网格和色标共同使用的完整LookupTable。 */
+ vtkSmartPointer m_pLookupTable;
+ /** @brief 与线性或对数模式对应的ASCII色标标题。 */
+ QString m_sScalarBarTitle;
+ /** @brief 自动范围为单值时为true,手工范围始终为false。 */
+ bool m_bSingleValueMode;
+};
+
+/** @brief 统一构造结果网格和色标使用的颜色映射状态。 */
+class nmPebiResultDisplayStateBuilder
+{
+public:
+ /**
+ * @brief 事务式构造网格和色标共用的完整颜色显示状态。
+ * @param pSnapshot 只读结果快照强引用。
+ * @param sPropertyId 快照中的稳定属性ID。
+ * @param oRequestedSettings 待规范化和校验的显示设置。
+ * @param oState 成功时接收完整状态;失败时保持原值不变。
+ * @param pError 可选错误输出;进入函数后先清空。
+ * @return 属性、范围、比例模式和LUT全部构造成功时返回true。
+ */
+ static bool build(
+ const QSharedPointer& pSnapshot,
+ const QString& sPropertyId,
+ const nmPebiResultDisplaySettings& oRequestedSettings,
+ nmPebiResultDisplayState& oState,
+ QString* pError = nullptr);
+
+private:
+ /** @brief 纯静态构造器,不允许创建实例。 */
+ nmPebiResultDisplayStateBuilder();
+};
+
+#endif // NMPEBIRESULTDISPLAYSTATEBUILDER_H
diff --git a/Include/nmNum/nmSubWxs/nmWxPebiResultAnimationExportDlg.h b/Include/nmNum/nmSubWxs/nmWxPebiResultAnimationExportDlg.h
new file mode 100644
index 00000000..068285f4
--- /dev/null
+++ b/Include/nmNum/nmSubWxs/nmWxPebiResultAnimationExportDlg.h
@@ -0,0 +1,101 @@
+#ifndef NMWXPEBIRESULTANIMATIONEXPORTDLG_H
+#define NMWXPEBIRESULTANIMATIONEXPORTDLG_H
+
+#include "nmSubWxs_global.h"
+#include "nmPebiResultAnimationExportSettings.h"
+
+#include
+#include
+#include
+
+class QComboBox;
+class QLabel;
+class QSpinBox;
+
+/** @brief 编辑当前动态结果的动画导出参数,不选择目标文件。 */
+class NM_SUB_WXS_EXPORT nmWxPebiResultAnimationExportDlg
+ : public QDialog
+{
+ Q_OBJECT
+
+public:
+ /**
+ * @brief 创建动画导出参数对话框。
+ * @param vecFrameTimesHours 动态属性各帧对应的小时值。
+ * @param oCurrentViewportSize 当前QVTK视口的像素尺寸。
+ * @param pParent Qt父窗口。
+ */
+ explicit nmWxPebiResultAnimationExportDlg(
+ const QVector& vecFrameTimesHours,
+ const QSize& oCurrentViewportSize,
+ QWidget* pParent = nullptr);
+
+ /** @brief 返回用户确认后的参数;仅在对话框Accepted后使用。 */
+ nmPebiResultAnimationExportSettings getSettings() const;
+
+private slots:
+ /** @brief 保证结束帧不早于起始帧,并刷新采样上限和摘要。 */
+ void onFrameRangeChanged();
+ /** @brief 应用当前视口或固定分辨率,并切换自定义输入可用状态。 */
+ void onResolutionPresetChanged(int nIndex);
+ /** @brief 在输入完成后把自定义宽高向上规范为偶数。 */
+ void normalizeCustomDimensions();
+ /** @brief 按当前参数刷新输出帧数和预计时长。 */
+ void updateSummary();
+ /** @brief 规范化并严格校验参数,成功后接受对话框。 */
+ void acceptSettings();
+
+private:
+ Q_DISABLE_COPY(nmWxPebiResultAnimationExportDlg)
+
+ /** @brief 对话框内置的输出分辨率来源。 */
+ enum ResolutionPreset
+ {
+ /** 使用打开对话框时记录的QVTK视口尺寸。 */
+ Resolution_CurrentView = 0,
+ /** 固定输出1280x720。 */
+ Resolution_720p,
+ /** 固定输出1920x1080。 */
+ Resolution_1080p,
+ /** 使用用户输入的宽度和高度。 */
+ Resolution_Custom
+ };
+
+ /** @brief 创建全部控件并建立信号连接。 */
+ void createUi();
+ /** @brief 将小时值及其零基帧下标填入起止帧下拉框。 */
+ void populateFrameItems();
+ /** @brief 从控件收集一份不改变界面状态的规范化参数。 */
+ nmPebiResultAnimationExportSettings collectSettings() const;
+ /** @brief 将像素尺寸限制到2~8192并向上修正为偶数。 */
+ static int normalizeEvenDimension(int nValue);
+
+ /** @brief 各零基帧下标对应的时间,单位为小时。 */
+ QVector m_vecFrameTimesHours;
+ /** @brief 打开对话框时冻结的QVTK视口像素尺寸。 */
+ QSize m_oCurrentViewportSize;
+ /** @brief 用户确认后保存的规范化导出参数。 */
+ nmPebiResultAnimationExportSettings m_oAcceptedSettings;
+ /** @brief 目标视频帧率输入框。 */
+ QSpinBox* m_pFpsSpinBox;
+ /** @brief 导出闭区间的起始帧下拉框。 */
+ QComboBox* m_pStartFrameCombo;
+ /** @brief 导出闭区间的结束帧下拉框。 */
+ QComboBox* m_pEndFrameCombo;
+ /** @brief 原始结果帧采样间隔输入框。 */
+ QSpinBox* m_pSamplingIntervalSpinBox;
+ /** @brief 当前视口、固定尺寸和自定义尺寸的选择框。 */
+ QComboBox* m_pResolutionCombo;
+ /** @brief 输出宽度输入框,界面最终显示偶数像素值。 */
+ QSpinBox* m_pWidthSpinBox;
+ /** @brief 输出高度输入框,界面最终显示偶数像素值。 */
+ QSpinBox* m_pHeightSpinBox;
+ /** @brief 按当前帧范围和采样间隔计算的输出帧数。 */
+ QLabel* m_pOutputFrameCountLabel;
+ /** @brief 按输出帧数和帧率计算的预计视频时长。 */
+ QLabel* m_pEstimatedDurationLabel;
+ /** @brief 参数校验失败时显示的错误文字。 */
+ QLabel* m_pErrorLabel;
+};
+
+#endif // NMWXPEBIRESULTANIMATIONEXPORTDLG_H
diff --git a/Include/nmNum/nmSubWxs/nmWxPebiResultControlBar.h b/Include/nmNum/nmSubWxs/nmWxPebiResultControlBar.h
index 276a6f23..9b4c92e1 100644
--- a/Include/nmNum/nmSubWxs/nmWxPebiResultControlBar.h
+++ b/Include/nmNum/nmSubWxs/nmWxPebiResultControlBar.h
@@ -7,6 +7,7 @@
#include
#include
+class QAction;
class QComboBox;
class QToolButton;
class QVariant;
@@ -41,12 +42,18 @@ public:
* @note 仅供组合窗口查询或配置,调用方不得保存到控制条生命周期之外。
*/
nmPebiResultPlaybackController* getPlaybackController() const;
+ /** @brief 返回工具按钮和结果视图右键菜单共用的动画导出动作。 */
+ QAction* getExportAnimationAction() const;
+ /** @brief 设置当前窗口的导出锁定状态并立即刷新全部控件。 */
+ void setExportInProgress(bool bInProgress);
signals:
/** @brief 一次明确的用户操作已经成功提交,供组合窗口清除旧普通错误。 */
void operationSucceeded();
/** @brief 转发回放控制器错误,供后续组合窗口显示非阻塞提示。 */
void operationFailed(const QString& sError);
+ /** @brief 用户从共用QAction请求导出当前动态属性。 */
+ void exportAnimationRequested();
private slots:
/** @brief 用户选择属性时提交稳定属性 ID。 */
@@ -67,6 +74,8 @@ private slots:
void onPlayPauseClicked();
/** @brief 仅在非播放状态下打开当前窗口独立的动画设置对话框。 */
void onAnimationSettingsClicked();
+ /** @brief 校验本地播放和导出状态后转发动画导出请求。 */
+ void onExportAnimationTriggered();
/** @brief 从 Controller getter 重建或刷新控件镜像状态。 */
void refreshFromController();
/** @brief 将控制器错误转发给后续组合窗口。 */
@@ -109,6 +118,12 @@ private:
QToolButton* m_pPlayPauseButton;
/** @brief 打开速度与循环设置对话框。 */
QToolButton* m_pSettingsButton;
+ /** @brief 工具按钮和右键菜单共用的动画导出动作。 */
+ QAction* m_pExportAction;
+ /** @brief 承载共用导出动作的底部图标按钮。 */
+ QToolButton* m_pExportButton;
+ /** @brief 当前窗口是否正在执行参数选择、编码或文件发布事务。 */
+ bool m_bExportInProgress;
/** @brief 当前属性项对应的 Snapshot ID,仅用于避免重复重建 UI。 */
QString m_sDisplayedSnapshotId;
/** @brief 属性和时间列表最近一次完整展示的 Scene 成功绑定序号。 */
diff --git a/Include/nmNum/nmSubWxs/nmWxPebiResultViewWidget.h b/Include/nmNum/nmSubWxs/nmWxPebiResultViewWidget.h
index 0038bbc4..c4fe2585 100644
--- a/Include/nmNum/nmSubWxs/nmWxPebiResultViewWidget.h
+++ b/Include/nmNum/nmSubWxs/nmWxPebiResultViewWidget.h
@@ -64,6 +64,8 @@ private slots:
void onControlOperationSucceeded();
/** @brief 将 QVTK 视口尺寸同步给结果场景,不主动触发额外渲染。 */
void onViewportSizeChanged(int nWidth, int nHeight);
+ /** @brief 冻结当前显示状态并执行独立离屏动画导出。 */
+ void onExportAnimationRequested();
/** @brief 切换色标显隐。 */
void onScalarBarToggled(bool bVisible);
diff --git a/Src/nmNum/nmSubWxs/nmFFmpegVideoWriter.cpp b/Src/nmNum/nmSubWxs/nmFFmpegVideoWriter.cpp
new file mode 100644
index 00000000..0bf7d718
--- /dev/null
+++ b/Src/nmNum/nmSubWxs/nmFFmpegVideoWriter.cpp
@@ -0,0 +1,858 @@
+#include "nmFFmpegVideoWriter.h"
+
+#include
+#include
+#include
+#include
+
+#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
+
+#ifndef __STDC_CONSTANT_MACROS
+#define __STDC_CONSTANT_MACROS
+#endif
+
+extern "C" {
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+}
+
+#include
+#include
+#include
+
+#endif
+
+namespace {
+
+QString writerText(const char* pText)
+{
+ return QCoreApplication::translate("nmFFmpegVideoWriter", pText);
+}
+
+QString normalizedExtension(const QString& sExtension)
+{
+ QString sNormalized = sExtension.trimmed().toLower();
+ if(sNormalized.startsWith('.')) {
+ sNormalized.remove(0, 1);
+ }
+ return sNormalized;
+}
+
+#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
+
+struct VideoFormatSpec
+{
+ const char* m_pExtension;
+ const char* m_pMuxerName;
+ AVCodecID m_eCodecId;
+ const char* m_pCodecName;
+ const char* m_pEncoderName;
+ AVPixelFormat m_ePixelFormat;
+ bool m_bMjpeg;
+};
+
+// 产品对外承诺的格式、容器和编码器是固定组合,能力探测与实际打开均使用此表。
+const VideoFormatSpec g_oFormatSpecs[] =
+{
+ { "mp4", "mp4", AV_CODEC_ID_MPEG4, "mpeg4", nullptr,
+ AV_PIX_FMT_YUV420P, false },
+ { "avi", "avi", AV_CODEC_ID_MJPEG, "mjpeg", nullptr,
+ AV_PIX_FMT_YUVJ422P, true },
+ { "mov", "mov", AV_CODEC_ID_MPEG4, "mpeg4", nullptr,
+ AV_PIX_FMT_YUV420P, false },
+ { "mpg", "mpeg", AV_CODEC_ID_MPEG2VIDEO, "mpeg2video", nullptr,
+ AV_PIX_FMT_YUV420P, false },
+ { "webm", "webm", AV_CODEC_ID_VP8, "vp8", "libvpx",
+ AV_PIX_FMT_YUV420P, false },
+ { "mkv", "matroska", AV_CODEC_ID_MPEG4, "mpeg4", nullptr,
+ AV_PIX_FMT_YUV420P, false },
+ { "wmv", "asf", AV_CODEC_ID_WMV2, "wmv2", nullptr,
+ AV_PIX_FMT_YUV420P, false },
+ { "flv", "flv", AV_CODEC_ID_FLV1, "flv", nullptr,
+ AV_PIX_FMT_YUV420P, false }
+};
+
+const int FORMAT_SPEC_COUNT =
+ sizeof(g_oFormatSpecs) / sizeof(g_oFormatSpecs[0]);
+
+const VideoFormatSpec* findFormatSpec(const QString& sExtension)
+{
+ const QByteArray aExtension =
+ normalizedExtension(sExtension).toLatin1();
+ for(int nIndex = 0; nIndex < FORMAT_SPEC_COUNT; ++nIndex) {
+ if(aExtension == g_oFormatSpecs[nIndex].m_pExtension) {
+ return &g_oFormatSpecs[nIndex];
+ }
+ }
+ return nullptr;
+}
+
+AVCodec* findEncoder(const VideoFormatSpec& oSpec)
+{
+ return oSpec.m_pEncoderName != nullptr
+ ? avcodec_find_encoder_by_name(oSpec.m_pEncoderName)
+ : avcodec_find_encoder(oSpec.m_eCodecId);
+}
+
+const char* requestedEncoderName(const VideoFormatSpec& oSpec)
+{
+ return oSpec.m_pEncoderName != nullptr
+ ? oSpec.m_pEncoderName : oSpec.m_pCodecName;
+}
+
+QString ffmpegErrorText(int nError)
+{
+ char pBuffer[256] = { 0 };
+ if(av_strerror(nError, pBuffer, sizeof(pBuffer)) == 0) {
+ return QString::fromLocal8Bit(pBuffer);
+ }
+ return writerText("Unknown FFmpeg error.");
+}
+
+int ffmpegMajorVersion(unsigned nVersion)
+{
+ return static_cast((nVersion >> 16) & 0xffU);
+}
+
+bool inspectBackend(QString& sError)
+{
+ // 读取实际加载的DLL版本,不使用编译期宏代替运行时ABI校验。
+ const int nAvformatMajor = ffmpegMajorVersion(avformat_version());
+ const int nAvcodecMajor = ffmpegMajorVersion(avcodec_version());
+ const int nAvutilMajor = ffmpegMajorVersion(avutil_version());
+ const int nSwscaleMajor = ffmpegMajorVersion(swscale_version());
+ if(nAvformatMajor != 54 || nAvcodecMajor != 54 ||
+ nAvutilMajor != 52 || nSwscaleMajor != 2) {
+ sError = writerText(
+ "The FFmpeg runtime is incompatible. Expected "
+ "avformat/avcodec/avutil/swscale major versions 54/54/52/2, "
+ "but found %1/%2/%3/%4.")
+ .arg(nAvformatMajor)
+ .arg(nAvcodecMajor)
+ .arg(nAvutilMajor)
+ .arg(nSwscaleMajor);
+ return false;
+ }
+
+ av_register_all();
+ for(int nIndex = 0; nIndex < FORMAT_SPEC_COUNT; ++nIndex) {
+ const VideoFormatSpec& oSpec = g_oFormatSpecs[nIndex];
+ AVOutputFormat* pMuxer = av_guess_format(
+ oSpec.m_pMuxerName, nullptr, nullptr);
+ if(pMuxer == nullptr) {
+ sError = writerText(
+ "Video format .%1 is unavailable because muxer \"%2\" is missing.")
+ .arg(QString::fromLatin1(oSpec.m_pExtension))
+ .arg(QString::fromLatin1(oSpec.m_pMuxerName));
+ return false;
+ }
+
+ AVCodec* pEncoder = findEncoder(oSpec);
+ if(pEncoder == nullptr || pEncoder->id != oSpec.m_eCodecId) {
+ sError = writerText(
+ "Video format .%1 is unavailable because encoder \"%2\" is missing.")
+ .arg(QString::fromLatin1(oSpec.m_pExtension))
+ .arg(QString::fromLatin1(requestedEncoderName(oSpec)));
+ return false;
+ }
+
+ const int nCodecSupport = avformat_query_codec(
+ pMuxer, oSpec.m_eCodecId, FF_COMPLIANCE_NORMAL);
+ // FFmpeg 1.1中负值表示无法判断;只有明确返回0时才能认定组合不受支持。
+ if(nCodecSupport == 0) {
+ sError = writerText(
+ "Video format .%1 is unavailable because muxer \"%2\" "
+ "does not support codec \"%3\".")
+ .arg(QString::fromLatin1(oSpec.m_pExtension))
+ .arg(QString::fromLatin1(oSpec.m_pMuxerName))
+ .arg(QString::fromLatin1(oSpec.m_pCodecName));
+ return false;
+ }
+ }
+ return true;
+}
+
+#endif
+
+}
+
+nmFFmpegVideoWriter::VideoSettings::VideoSettings()
+ : m_nWidth(0),
+ m_nHeight(0),
+ m_nFramesPerSecond(0)
+{
+}
+
+class nmFFmpegVideoWriter::Private
+{
+public:
+ enum State
+ {
+ State_Closed = 0,
+ State_Opened,
+ State_Finished,
+ State_Failed,
+ State_Cancelled
+ };
+
+ Private()
+ : m_eState(State_Closed),
+ m_nWidth(0),
+ m_nHeight(0),
+ m_nFramesPerSecond(0),
+ m_nFrameNumber(0)
+#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
+ , m_pFormatContext(nullptr),
+ m_pStream(nullptr),
+ m_pCodecContext(nullptr),
+ m_pCodec(nullptr),
+ m_pFrame(nullptr),
+ m_pScaleContext(nullptr),
+ m_pAvioContext(nullptr),
+ m_bCodecOpened(false),
+ m_bPictureAllocated(false),
+ m_bMjpeg(false)
+#endif
+ {
+ }
+
+ State m_eState;
+ QString m_sTemporaryFilePath;
+ QString m_sExtension;
+ int m_nWidth;
+ int m_nHeight;
+ int m_nFramesPerSecond;
+ qint64 m_nFrameNumber;
+
+#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
+ AVFormatContext* m_pFormatContext;
+ AVStream* m_pStream;
+ AVCodecContext* m_pCodecContext;
+ AVCodec* m_pCodec;
+ AVFrame* m_pFrame;
+ SwsContext* m_pScaleContext;
+ AVIOContext* m_pAvioContext;
+ QFile m_oFile;
+ bool m_bCodecOpened;
+ bool m_bPictureAllocated;
+ bool m_bMjpeg;
+
+ static int writePacketCallback(void* pOpaque,
+ uint8_t* pBuffer,
+ int nBufferSize)
+ {
+ Private* pPrivate = static_cast(pOpaque);
+ if(pPrivate == nullptr || pBuffer == nullptr || nBufferSize < 0 ||
+ !pPrivate->m_oFile.isOpen()) {
+ return AVERROR(EIO);
+ }
+
+ // QFile可能只写入部分数据,必须循环到整包落盘;0同样视为IO失败。
+ qint64 nWrittenTotal = 0;
+ while(nWrittenTotal < nBufferSize) {
+ const qint64 nWritten = pPrivate->m_oFile.write(
+ reinterpret_cast(pBuffer) +
+ nWrittenTotal,
+ nBufferSize - nWrittenTotal);
+ if(nWritten <= 0) {
+ return AVERROR(EIO);
+ }
+ nWrittenTotal += nWritten;
+ }
+ return nBufferSize;
+ }
+
+ static int64_t seekCallback(void* pOpaque,
+ int64_t nOffset,
+ int nWhence)
+ {
+ Private* pPrivate = static_cast(pOpaque);
+ if(pPrivate == nullptr || !pPrivate->m_oFile.isOpen()) {
+ return AVERROR(EIO);
+ }
+
+ // MP4/MOV会在Trailer阶段回写文件头,因此自定义IO必须完整支持Seek。
+ const int nCleanWhence = nWhence & ~AVSEEK_FORCE;
+ if(nCleanWhence == AVSEEK_SIZE) {
+ return pPrivate->m_oFile.size();
+ }
+
+ qint64 nBase = 0;
+ if(nCleanWhence == SEEK_CUR) {
+ nBase = pPrivate->m_oFile.pos();
+ } else if(nCleanWhence == SEEK_END) {
+ nBase = pPrivate->m_oFile.size();
+ } else if(nCleanWhence != SEEK_SET) {
+ return AVERROR(EINVAL);
+ }
+
+ if((nOffset > 0 && nBase > LLONG_MAX - nOffset) ||
+ (nOffset < 0 && nOffset < -nBase)) {
+ return AVERROR(EINVAL);
+ }
+ const qint64 nTarget = nBase + nOffset;
+ if(nTarget < 0 || !pPrivate->m_oFile.seek(nTarget)) {
+ return AVERROR(EIO);
+ }
+ return pPrivate->m_oFile.pos();
+ }
+
+ bool writeEncodedPacket(AVPacket& oPacket, QString* pError)
+ {
+ // 正常编码和刷新编码器产生的Packet统一在此换算到流时间基。
+ oPacket.stream_index = m_pStream->index;
+ if(oPacket.pts != AV_NOPTS_VALUE) {
+ oPacket.pts = av_rescale_q(
+ oPacket.pts,
+ m_pCodecContext->time_base,
+ m_pStream->time_base);
+ }
+ if(oPacket.dts != AV_NOPTS_VALUE) {
+ oPacket.dts = av_rescale_q(
+ oPacket.dts,
+ m_pCodecContext->time_base,
+ m_pStream->time_base);
+ }
+ oPacket.duration = av_rescale_q(
+ 1, m_pCodecContext->time_base,
+ m_pStream->time_base);
+
+ const int nResult = av_interleaved_write_frame(
+ m_pFormatContext, &oPacket);
+ // FFmpeg n1.1在函数返回时已经接管Packet数据,无论返回值如何均不得释放。
+ if(nResult < 0) {
+ if(pError != nullptr) {
+ *pError = writerText("Unable to write the encoded video packet: %1")
+ .arg(ffmpegErrorText(nResult));
+ }
+ return false;
+ }
+ return true;
+ }
+
+ bool flushEncoder(QString* pError)
+ {
+ if(m_pCodec == nullptr ||
+ (m_pCodec->capabilities & CODEC_CAP_DELAY) == 0) {
+ return true;
+ }
+
+ for(;;) {
+ AVPacket oPacket;
+ av_init_packet(&oPacket);
+ oPacket.data = nullptr;
+ oPacket.size = 0;
+ int nGotPacket = 0;
+ const int nResult = avcodec_encode_video2(
+ m_pCodecContext, &oPacket, nullptr, &nGotPacket);
+ if(nResult < 0) {
+ av_free_packet(&oPacket);
+ if(pError != nullptr) {
+ *pError = writerText("Unable to flush the video encoder: %1")
+ .arg(ffmpegErrorText(nResult));
+ }
+ return false;
+ }
+ if(nGotPacket == 0) {
+ av_free_packet(&oPacket);
+ return true;
+ }
+ // 写入函数被调用后Muxer已接管Packet,返回失败时也不能再次释放。
+ if(!writeEncodedPacket(oPacket, pError)) {
+ return false;
+ }
+ }
+ }
+
+ void releaseAvioContext()
+ {
+ // 先断开FormatContext,防止后续释放阶段误用已经销毁的自定义AVIO。
+ if(m_pFormatContext != nullptr) {
+ m_pFormatContext->pb = nullptr;
+ }
+ if(m_pAvioContext != nullptr) {
+ av_freep(&m_pAvioContext->buffer);
+ av_freep(&m_pAvioContext);
+ }
+ }
+
+ void releaseCodecAndFormat()
+ {
+ if(m_pScaleContext != nullptr) {
+ sws_freeContext(m_pScaleContext);
+ m_pScaleContext = nullptr;
+ }
+ if(m_pFrame != nullptr) {
+ if(m_bPictureAllocated) {
+ avpicture_free(reinterpret_cast(m_pFrame));
+ m_bPictureAllocated = false;
+ }
+ av_free(m_pFrame);
+ m_pFrame = nullptr;
+ }
+ if(m_bCodecOpened && m_pCodecContext != nullptr) {
+ avcodec_close(m_pCodecContext);
+ m_bCodecOpened = false;
+ }
+ if(m_pFormatContext != nullptr) {
+ avformat_free_context(m_pFormatContext);
+ m_pFormatContext = nullptr;
+ }
+ m_pStream = nullptr;
+ m_pCodecContext = nullptr;
+ m_pCodec = nullptr;
+ }
+
+ void abortAndRemoveTemporaryFile()
+ {
+ // 取消和失败不写Trailer,也绝不进入最终文件发布事务。
+ releaseAvioContext();
+ if(m_oFile.isOpen()) {
+ m_oFile.close();
+ }
+ releaseCodecAndFormat();
+ if(!m_sTemporaryFilePath.isEmpty()) {
+ QFile::remove(m_sTemporaryFilePath);
+ }
+ }
+#endif
+};
+
+nmFFmpegVideoWriter::nmFFmpegVideoWriter()
+ : m_pPrivate(new Private())
+{
+}
+
+nmFFmpegVideoWriter::~nmFFmpegVideoWriter()
+{
+ if(m_pPrivate != nullptr) {
+ if(m_pPrivate->m_eState == Private::State_Opened) {
+ cancel();
+ }
+ delete m_pPrivate;
+ m_pPrivate = nullptr;
+ }
+}
+
+bool nmFFmpegVideoWriter::open(
+ const VideoSettings& oSettings,
+ QString* pError)
+{
+ if(pError != nullptr) {
+ pError->clear();
+ }
+ if(m_pPrivate == nullptr ||
+ m_pPrivate->m_eState == Private::State_Opened ||
+ oSettings.m_sTemporaryFilePath.isEmpty() ||
+ !isSupportedExtension(oSettings.m_sFileExtension) ||
+ oSettings.m_nWidth < 2 || oSettings.m_nWidth > 8192 ||
+ oSettings.m_nHeight < 2 || oSettings.m_nHeight > 8192 ||
+ (oSettings.m_nWidth % 2) != 0 ||
+ (oSettings.m_nHeight % 2) != 0 ||
+ oSettings.m_nFramesPerSecond < 1 ||
+ oSettings.m_nFramesPerSecond > 5000) {
+ if(pError != nullptr) {
+ *pError = writerText("The video encoder settings are invalid.");
+ }
+ return false;
+ }
+
+#ifndef NM_ENABLE_FFMPEG_VIDEO_EXPORT
+ if(pError != nullptr) {
+ *pError = writerText("The video encoding components are unavailable.");
+ }
+ return false;
+#else
+ QString sBackendError;
+ if(!isBackendAvailable(&sBackendError)) {
+ if(pError != nullptr) {
+ *pError = sBackendError;
+ }
+ return false;
+ }
+
+ m_pPrivate->m_sTemporaryFilePath =
+ QFileInfo(oSettings.m_sTemporaryFilePath).absoluteFilePath();
+ m_pPrivate->m_sExtension =
+ normalizedExtension(oSettings.m_sFileExtension);
+ m_pPrivate->m_nWidth = oSettings.m_nWidth;
+ m_pPrivate->m_nHeight = oSettings.m_nHeight;
+ m_pPrivate->m_nFramesPerSecond = oSettings.m_nFramesPerSecond;
+ m_pPrivate->m_nFrameNumber = 0;
+ m_pPrivate->m_eState = Private::State_Failed;
+
+ const VideoFormatSpec* pSpec =
+ findFormatSpec(m_pPrivate->m_sExtension);
+ m_pPrivate->m_pCodec = pSpec == nullptr
+ ? nullptr : findEncoder(*pSpec);
+ if(pSpec == nullptr || m_pPrivate->m_pCodec == nullptr ||
+ avformat_alloc_output_context2(
+ &m_pPrivate->m_pFormatContext, nullptr,
+ pSpec->m_pMuxerName, nullptr) < 0 ||
+ m_pPrivate->m_pFormatContext == nullptr) {
+ if(pError != nullptr) {
+ *pError = writerText("Unable to initialize the video container.");
+ }
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+
+ m_pPrivate->m_pStream = avformat_new_stream(
+ m_pPrivate->m_pFormatContext, m_pPrivate->m_pCodec);
+ if(m_pPrivate->m_pStream == nullptr) {
+ if(pError != nullptr) {
+ *pError = writerText("Unable to create the video stream.");
+ }
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+
+ m_pPrivate->m_pCodecContext = m_pPrivate->m_pStream->codec;
+ AVCodecContext* pCodecContext = m_pPrivate->m_pCodecContext;
+ pCodecContext->codec_id = pSpec->m_eCodecId;
+ pCodecContext->codec_type = AVMEDIA_TYPE_VIDEO;
+ pCodecContext->width = oSettings.m_nWidth;
+ pCodecContext->height = oSettings.m_nHeight;
+ pCodecContext->time_base.num = 1;
+ pCodecContext->time_base.den = oSettings.m_nFramesPerSecond;
+ m_pPrivate->m_pStream->time_base = pCodecContext->time_base;
+ pCodecContext->gop_size = qMax(1, oSettings.m_nFramesPerSecond * 2);
+ pCodecContext->max_b_frames = 0;
+ pCodecContext->pix_fmt = pSpec->m_ePixelFormat;
+ // 以1080p/15 FPS的8 Mbps为基准缩放,计算过程保持64位范围。
+ const double dScaledBitRate = 8000000.0 *
+ static_cast(oSettings.m_nWidth) *
+ static_cast(oSettings.m_nHeight) *
+ static_cast(oSettings.m_nFramesPerSecond) /
+ (1920.0 * 1080.0 * 15.0);
+ const qint64 nBitRate = qBound(
+ 500000, static_cast(dScaledBitRate + 0.5),
+ 50000000);
+ pCodecContext->bit_rate = static_cast(nBitRate);
+ m_pPrivate->m_bMjpeg = pSpec->m_bMjpeg;
+ if(m_pPrivate->m_bMjpeg) {
+ pCodecContext->flags |= CODEC_FLAG_QSCALE;
+ pCodecContext->global_quality = FF_QP2LAMBDA * 2;
+ }
+ if((m_pPrivate->m_pFormatContext->oformat->flags &
+ AVFMT_GLOBALHEADER) != 0) {
+ pCodecContext->flags |= CODEC_FLAG_GLOBAL_HEADER;
+ }
+
+ int nResult = avcodec_open2(
+ pCodecContext, m_pPrivate->m_pCodec, nullptr);
+ if(nResult < 0) {
+ if(pError != nullptr) {
+ *pError = writerText("Unable to open the video encoder: %1")
+ .arg(ffmpegErrorText(nResult));
+ }
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+ m_pPrivate->m_bCodecOpened = true;
+
+ m_pPrivate->m_pFrame = avcodec_alloc_frame();
+ if(m_pPrivate->m_pFrame == nullptr ||
+ avpicture_alloc(
+ reinterpret_cast(m_pPrivate->m_pFrame),
+ pSpec->m_ePixelFormat,
+ oSettings.m_nWidth, oSettings.m_nHeight) < 0) {
+ if(pError != nullptr) {
+ *pError = writerText("Unable to allocate the video frame buffer.");
+ }
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+ m_pPrivate->m_bPictureAllocated = true;
+ m_pPrivate->m_pFrame->width = oSettings.m_nWidth;
+ m_pPrivate->m_pFrame->height = oSettings.m_nHeight;
+ m_pPrivate->m_pFrame->format = pSpec->m_ePixelFormat;
+
+ m_pPrivate->m_pScaleContext = sws_getContext(
+ oSettings.m_nWidth, oSettings.m_nHeight,
+ AV_PIX_FMT_RGB24,
+ oSettings.m_nWidth, oSettings.m_nHeight,
+ pSpec->m_ePixelFormat,
+ SWS_BILINEAR, nullptr, nullptr, nullptr);
+ if(m_pPrivate->m_pScaleContext == nullptr) {
+ if(pError != nullptr) {
+ *pError = writerText("Unable to initialize the video color conversion.");
+ }
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+
+ QFile::remove(m_pPrivate->m_sTemporaryFilePath);
+ m_pPrivate->m_oFile.setFileName(m_pPrivate->m_sTemporaryFilePath);
+ if(!m_pPrivate->m_oFile.open(
+ QIODevice::ReadWrite | QIODevice::Truncate)) {
+ if(pError != nullptr) {
+ *pError = writerText("Unable to create the temporary video file.");
+ }
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+
+ // QFile负责Unicode路径,FFmpeg只通过自定义AVIO读写,不直接打开文件名。
+ const int nAvioBufferSize = 32768;
+ unsigned char* pAvioBuffer = static_cast(
+ av_malloc(nAvioBufferSize));
+ if(pAvioBuffer != nullptr) {
+ m_pPrivate->m_pAvioContext = avio_alloc_context(
+ pAvioBuffer, nAvioBufferSize, 1,
+ m_pPrivate, nullptr,
+ &Private::writePacketCallback,
+ &Private::seekCallback);
+ }
+ if(m_pPrivate->m_pAvioContext == nullptr) {
+ av_free(pAvioBuffer);
+ if(pError != nullptr) {
+ *pError = writerText("Unable to initialize the video file output.");
+ }
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+ m_pPrivate->m_pAvioContext->seekable = AVIO_SEEKABLE_NORMAL;
+ m_pPrivate->m_pFormatContext->pb = m_pPrivate->m_pAvioContext;
+ m_pPrivate->m_pFormatContext->flags |= AVFMT_FLAG_CUSTOM_IO;
+
+ // filename仅用于让Muxer识别扩展名;真实输出目标由FormatContext::pb提供。
+ const QByteArray aPlaceholder =
+ QString::fromLatin1("output.%1")
+ .arg(m_pPrivate->m_sExtension).toLatin1();
+ qstrncpy(m_pPrivate->m_pFormatContext->filename,
+ aPlaceholder.constData(),
+ sizeof(m_pPrivate->m_pFormatContext->filename));
+ nResult = avformat_write_header(
+ m_pPrivate->m_pFormatContext, nullptr);
+ if(nResult < 0) {
+ if(pError != nullptr) {
+ *pError = writerText("Unable to write the video header: %1")
+ .arg(ffmpegErrorText(nResult));
+ }
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+ m_pPrivate->m_eState = Private::State_Opened;
+ return true;
+#endif
+}
+
+bool nmFFmpegVideoWriter::writeRgb24Frame(
+ const unsigned char* pData,
+ int nStride,
+ bool bBottomUp,
+ QString* pError)
+{
+ if(pError != nullptr) {
+ pError->clear();
+ }
+ if(m_pPrivate == nullptr ||
+ m_pPrivate->m_eState != Private::State_Opened ||
+ pData == nullptr || nStride < m_pPrivate->m_nWidth * 3) {
+ if(pError != nullptr) {
+ *pError = writerText("The RGB video frame is invalid.");
+ }
+ return false;
+ }
+
+#ifndef NM_ENABLE_FFMPEG_VIDEO_EXPORT
+ if(pError != nullptr) {
+ *pError = writerText("The video encoding components are unavailable.");
+ }
+ return false;
+#else
+ const uint8_t* pSourceData[4] = { nullptr, nullptr, nullptr, nullptr };
+ int pSourceStride[4] = { 0, 0, 0, 0 };
+ pSourceData[0] = bBottomUp
+ ? pData + static_cast(m_pPrivate->m_nHeight - 1) *
+ nStride
+ : pData;
+ pSourceStride[0] = bBottomUp ? -nStride : nStride;
+ const int nScaledRows = sws_scale(
+ m_pPrivate->m_pScaleContext,
+ pSourceData, pSourceStride,
+ 0, m_pPrivate->m_nHeight,
+ m_pPrivate->m_pFrame->data,
+ m_pPrivate->m_pFrame->linesize);
+ if(nScaledRows != m_pPrivate->m_nHeight) {
+ if(pError != nullptr) {
+ *pError = writerText("Unable to convert the video frame colors.");
+ }
+ m_pPrivate->m_eState = Private::State_Failed;
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+
+ // PTS使用连续输出序号,不能使用被采样的原始结果帧下标。
+ m_pPrivate->m_pFrame->pts = m_pPrivate->m_nFrameNumber;
+ if(m_pPrivate->m_bMjpeg) {
+ m_pPrivate->m_pFrame->quality =
+ m_pPrivate->m_pCodecContext->global_quality;
+ }
+ AVPacket oPacket;
+ av_init_packet(&oPacket);
+ oPacket.data = nullptr;
+ oPacket.size = 0;
+ int nGotPacket = 0;
+ const int nResult = avcodec_encode_video2(
+ m_pPrivate->m_pCodecContext,
+ &oPacket, m_pPrivate->m_pFrame, &nGotPacket);
+ if(nResult < 0) {
+ av_free_packet(&oPacket);
+ if(pError != nullptr) {
+ *pError = writerText("Unable to encode the video frame: %1")
+ .arg(ffmpegErrorText(nResult));
+ }
+ m_pPrivate->m_eState = Private::State_Failed;
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+ ++m_pPrivate->m_nFrameNumber;
+ if(nGotPacket == 0) {
+ av_free_packet(&oPacket);
+ return true;
+ }
+ if(!m_pPrivate->writeEncodedPacket(oPacket, pError)) {
+ m_pPrivate->m_eState = Private::State_Failed;
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+ return true;
+#endif
+}
+
+bool nmFFmpegVideoWriter::finish(QString* pError)
+{
+ if(pError != nullptr) {
+ pError->clear();
+ }
+ if(m_pPrivate == nullptr ||
+ m_pPrivate->m_eState != Private::State_Opened) {
+ if(pError != nullptr) {
+ *pError = writerText("The video writer is not open.");
+ }
+ return false;
+ }
+
+#ifndef NM_ENABLE_FFMPEG_VIDEO_EXPORT
+ if(pError != nullptr) {
+ *pError = writerText("The video encoding components are unavailable.");
+ }
+ return false;
+#else
+ // 先离开Opened状态,确保任何失败路径和析构都不会再次执行finish。
+ m_pPrivate->m_eState = Private::State_Failed;
+ if(!m_pPrivate->flushEncoder(pError)) {
+ m_pPrivate->abortAndRemoveTemporaryFile();
+ return false;
+ }
+
+ // Trailer必须在关闭自定义IO前完成,MP4/MOV会在这里Seek并回写文件头。
+ const int nTrailerResult = av_write_trailer(
+ m_pPrivate->m_pFormatContext);
+ avio_flush(m_pPrivate->m_pAvioContext);
+ const int nAvioError = m_pPrivate->m_pAvioContext->error;
+ const bool bFileFlushed = m_pPrivate->m_oFile.flush();
+ m_pPrivate->m_oFile.close();
+
+ m_pPrivate->releaseAvioContext();
+ m_pPrivate->releaseCodecAndFormat();
+
+ if(nTrailerResult < 0 || nAvioError != 0 || !bFileFlushed) {
+ if(pError != nullptr) {
+ if(nTrailerResult < 0) {
+ *pError = writerText("Unable to finalize the video container: %1")
+ .arg(ffmpegErrorText(nTrailerResult));
+ } else if(nAvioError != 0) {
+ *pError = writerText("Unable to flush the video output: %1")
+ .arg(ffmpegErrorText(nAvioError));
+ } else {
+ *pError = writerText("Unable to flush the temporary video file.");
+ }
+ }
+ QFile::remove(m_pPrivate->m_sTemporaryFilePath);
+ return false;
+ }
+
+ const QFileInfo oTemporaryFile(m_pPrivate->m_sTemporaryFilePath);
+ if(!oTemporaryFile.isFile() || oTemporaryFile.size() <= 0) {
+ if(pError != nullptr) {
+ *pError = writerText("The temporary video file is empty.");
+ }
+ QFile::remove(m_pPrivate->m_sTemporaryFilePath);
+ return false;
+ }
+
+ m_pPrivate->m_eState = Private::State_Finished;
+ return true;
+#endif
+}
+
+void nmFFmpegVideoWriter::cancel()
+{
+ if(m_pPrivate == nullptr ||
+ m_pPrivate->m_eState != Private::State_Opened) {
+ return;
+ }
+ m_pPrivate->m_eState = Private::State_Cancelled;
+#ifdef NM_ENABLE_FFMPEG_VIDEO_EXPORT
+ m_pPrivate->abortAndRemoveTemporaryFile();
+#endif
+}
+
+bool nmFFmpegVideoWriter::isBackendAvailable(QString* pError)
+{
+ if(pError != nullptr) {
+ pError->clear();
+ }
+#ifndef NM_ENABLE_FFMPEG_VIDEO_EXPORT
+ if(pError != nullptr) {
+ *pError = writerText("The video encoding components are unavailable.");
+ }
+ return false;
+#else
+ static int nCachedAvailability = -1;
+ static QString sCachedError;
+ if(nCachedAvailability >= 0) {
+ if(nCachedAvailability == 0 && pError != nullptr) {
+ *pError = sCachedError;
+ }
+ return nCachedAvailability == 1;
+ }
+
+ // 八种正式格式采用全有或全无策略,避免按钮可用后才暴露缺失组件。
+ nCachedAvailability = inspectBackend(sCachedError) ? 1 : 0;
+ if(nCachedAvailability == 0 && pError != nullptr) {
+ *pError = sCachedError;
+ }
+ return nCachedAvailability == 1;
+#endif
+}
+
+QStringList nmFFmpegVideoWriter::getSupportedExtensions()
+{
+ QStringList listExtensions;
+ listExtensions << QString::fromLatin1("mp4")
+ << QString::fromLatin1("avi")
+ << QString::fromLatin1("mov")
+ << QString::fromLatin1("mpg")
+ << QString::fromLatin1("webm")
+ << QString::fromLatin1("mkv")
+ << QString::fromLatin1("wmv")
+ << QString::fromLatin1("flv");
+ return listExtensions;
+}
+
+bool nmFFmpegVideoWriter::isSupportedExtension(
+ const QString& sExtension)
+{
+ return getSupportedExtensions().contains(
+ normalizedExtension(sExtension));
+}
diff --git a/Src/nmNum/nmSubWxs/nmPebiResultAnimationExportSettings.cpp b/Src/nmNum/nmSubWxs/nmPebiResultAnimationExportSettings.cpp
new file mode 100644
index 00000000..ef6fd1e9
--- /dev/null
+++ b/Src/nmNum/nmSubWxs/nmPebiResultAnimationExportSettings.cpp
@@ -0,0 +1,58 @@
+#include "nmPebiResultAnimationExportSettings.h"
+
+nmPebiResultAnimationExportSettings::nmPebiResultAnimationExportSettings()
+ : m_nFramesPerSecond(15),
+ m_nStartFrameIndex(0),
+ m_nEndFrameIndex(0),
+ m_nSamplingInterval(1),
+ m_nOutputWidth(2),
+ m_nOutputHeight(2)
+{
+}
+
+bool nmPebiResultAnimationExportSettings::isValid(
+ int nAvailableFrameCount) const
+{
+ return nAvailableFrameCount > 0 &&
+ m_nFramesPerSecond >= 1 && m_nFramesPerSecond <= 5000 &&
+ m_nStartFrameIndex >= 0 &&
+ m_nEndFrameIndex >= m_nStartFrameIndex &&
+ m_nEndFrameIndex < nAvailableFrameCount &&
+ m_nSamplingInterval >= 1 &&
+ m_nSamplingInterval <=
+ qMax(1, m_nEndFrameIndex - m_nStartFrameIndex) &&
+ m_nOutputWidth >= 2 && m_nOutputWidth <= 8192 &&
+ m_nOutputHeight >= 2 && m_nOutputHeight <= 8192 &&
+ (m_nOutputWidth % 2) == 0 &&
+ (m_nOutputHeight % 2) == 0;
+}
+
+QVector nmPebiResultAnimationExportSettings::buildFrameIndices() const
+{
+ QVector vecFrameIndices;
+ if(m_nStartFrameIndex < 0 ||
+ m_nEndFrameIndex < m_nStartFrameIndex ||
+ m_nSamplingInterval < 1) {
+ return vecFrameIndices;
+ }
+
+ // 先按间隔采样;不能整除时在循环后显式补入结束帧。
+ for(int nFrameIndex = m_nStartFrameIndex;
+ nFrameIndex <= m_nEndFrameIndex;
+ nFrameIndex += m_nSamplingInterval) {
+ vecFrameIndices.append(nFrameIndex);
+ if(m_nEndFrameIndex - nFrameIndex < m_nSamplingInterval) {
+ break;
+ }
+ }
+ if(vecFrameIndices.isEmpty() ||
+ vecFrameIndices.last() != m_nEndFrameIndex) {
+ vecFrameIndices.append(m_nEndFrameIndex);
+ }
+ return vecFrameIndices;
+}
+
+int nmPebiResultAnimationExportSettings::getOutputFrameCount() const
+{
+ return buildFrameIndices().size();
+}
diff --git a/Src/nmNum/nmSubWxs/nmPebiResultAnimationExporter.cpp b/Src/nmNum/nmSubWxs/nmPebiResultAnimationExporter.cpp
new file mode 100644
index 00000000..71a7a8c6
--- /dev/null
+++ b/Src/nmNum/nmSubWxs/nmPebiResultAnimationExporter.cpp
@@ -0,0 +1,557 @@
+#include "nmPebiResultAnimationExporter.h"
+
+#include "nmFFmpegVideoWriter.h"
+#include "nmPebiResultDisplayStateBuilder.h"
+#include "nmPebiResultPropertyCatalog.h"
+#include "nmPebiResultSnapshot.h"
+#include "nmPebiResultSnapshotRenderAdapter.h"
+#include "nmPebiResultWellAnnotationLayer.h"
+#include "nmVTKMeshLayer.h"
+#include "nmVTKPlanarScaleGridLayer.h"
+#include "nmVTKScalarBarLayer.h"
+#include "nmVTKScene.h"
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+
+#if defined(Q_OS_WIN)
+#include
+#endif
+
+namespace {
+
+const char* const EXPORT_MESH_LAYER_ID = "pebi.export.mesh";
+const char* const EXPORT_SCALAR_BAR_LAYER_ID = "pebi.export.scalar_bar";
+const char* const EXPORT_SCALE_GRID_LAYER_ID = "pebi.export.scale_grid";
+const char* const EXPORT_WELLS_LAYER_ID = "pebi.export.wells";
+
+QString exporterText(const char* pText)
+{
+ return QCoreApplication::translate(
+ "nmPebiResultAnimationExporter", pText);
+}
+
+bool getAdapterBounds(nmPebiResultSnapshotRenderAdapter& oAdapter,
+ vtkIdType nExpectedCellCount,
+ double dBounds[6])
+{
+ vtkAlgorithmOutput* pOutput = oAdapter.getOutputPort();
+ if(pOutput == nullptr || pOutput->GetProducer() == nullptr ||
+ oAdapter.getCellCount() != nExpectedCellCount ||
+ nExpectedCellCount <= 0) {
+ return false;
+ }
+ pOutput->GetProducer()->Update(pOutput->GetIndex());
+ vtkDataSet* pDataSet = vtkDataSet::SafeDownCast(
+ pOutput->GetProducer()->GetOutputDataObject(
+ pOutput->GetIndex()));
+ if(pDataSet == nullptr ||
+ pDataSet->GetNumberOfCells() != nExpectedCellCount) {
+ return false;
+ }
+ pDataSet->GetBounds(dBounds);
+ if(!vtkMath::AreBoundsInitialized(dBounds)) {
+ return false;
+ }
+ for(int nIndex = 0; nIndex < 6; ++nIndex) {
+ if(!vtkMath::IsFinite(dBounds[nIndex])) {
+ return false;
+ }
+ }
+ return dBounds[0] < dBounds[1] &&
+ dBounds[2] < dBounds[3] &&
+ dBounds[4] <= dBounds[5];
+}
+
+QString createTemporaryPath(const QString& sTargetPath)
+{
+ // 临时文件保留目标扩展名,Muxer才能按最终容器格式生成完整文件。
+ const QFileInfo oTargetInfo(sTargetPath);
+ const QString sToken = QUuid::createUuid().toString()
+ .remove('{').remove('}');
+ return QDir(oTargetInfo.absolutePath()).filePath(
+ QString::fromLatin1(".%1.nm-export-%2.%3")
+ .arg(oTargetInfo.completeBaseName())
+ .arg(sToken)
+ .arg(oTargetInfo.suffix()));
+}
+
+bool isNonEmptyFile(const QString& sFilePath)
+{
+ const QFileInfo oFileInfo(sFilePath);
+ return oFileInfo.isFile() && oFileInfo.size() > 0;
+}
+
+bool publishTemporaryFile(const QString& sTemporaryPath,
+ const QString& sTargetPath,
+ QString* pError)
+{
+ if(!isNonEmptyFile(sTemporaryPath)) {
+ if(pError != nullptr) {
+ *pError = exporterText(
+ "Unable to publish the completed video file.");
+ }
+ return false;
+ }
+
+ // 编码与发布是两个事务:只有非空临时视频完成后才允许触碰原目标。
+ const QFileInfo oTargetInfo(sTargetPath);
+ const QString sBackupPath = QDir(oTargetInfo.absolutePath()).filePath(
+ QString::fromLatin1(".%1.nm-backup-%2.%3")
+ .arg(oTargetInfo.completeBaseName())
+ .arg(QUuid::createUuid().toString().remove('{').remove('}'))
+ .arg(oTargetInfo.suffix()));
+#if defined(Q_OS_WIN)
+ const std::wstring wsTarget = QDir::toNativeSeparators(
+ QFileInfo(sTargetPath).absoluteFilePath()).toStdWString();
+ const std::wstring wsTemporary = QDir::toNativeSeparators(
+ QFileInfo(sTemporaryPath).absoluteFilePath()).toStdWString();
+ const std::wstring wsBackup = QDir::toNativeSeparators(
+ QFileInfo(sBackupPath).absoluteFilePath()).toStdWString();
+ if(QFileInfo(sTargetPath).exists()) {
+ QFile::remove(sBackupPath);
+ // ReplaceFileW原子替换目标,并让系统把旧文件保存到唯一备份路径。
+ if(ReplaceFileW(
+ wsTarget.c_str(), wsTemporary.c_str(),
+ wsBackup.c_str(), REPLACEFILE_WRITE_THROUGH,
+ nullptr, nullptr) != FALSE) {
+ QFile::remove(sBackupPath);
+ return true;
+ }
+
+ // ReplaceFileW失败时Windows仍可能已经生成备份,必须先恢复原文件。
+ if(QFileInfo(sBackupPath).exists()) {
+ if(MoveFileExW(
+ wsBackup.c_str(), wsTarget.c_str(),
+ MOVEFILE_REPLACE_EXISTING |
+ MOVEFILE_WRITE_THROUGH) == FALSE &&
+ QFileInfo(sBackupPath).exists()) {
+ if(pError != nullptr) {
+ *pError = exporterText(
+ "Unable to publish the completed video file.") +
+ QString::fromLatin1(" ") +
+ exporterText(
+ "The original file backup was retained at \"%1\".")
+ .arg(QDir::toNativeSeparators(sBackupPath));
+ }
+ return false;
+ }
+ }
+ } else {
+ if(MoveFileExW(
+ wsTemporary.c_str(), wsTarget.c_str(),
+ MOVEFILE_WRITE_THROUGH) != FALSE) {
+ return true;
+ }
+ }
+ if(pError != nullptr) {
+ *pError = exporterText(
+ "Unable to publish the completed video file.");
+ }
+ return false;
+#else
+ if(QFileInfo(sTargetPath).exists()) {
+ QFile::remove(sBackupPath);
+ if(!QFile::rename(sTargetPath, sBackupPath)) {
+ if(pError != nullptr) {
+ *pError = exporterText(
+ "Unable to publish the completed video file.");
+ }
+ return false;
+ }
+ if(QFile::rename(sTemporaryPath, sTargetPath)) {
+ QFile::remove(sBackupPath);
+ return true;
+ }
+ if(!QFile::rename(sBackupPath, sTargetPath) &&
+ QFileInfo(sBackupPath).exists() && pError != nullptr) {
+ *pError = exporterText(
+ "Unable to publish the completed video file.") +
+ QString::fromLatin1(" ") +
+ exporterText(
+ "The original file backup was retained at \"%1\".")
+ .arg(QDir::toNativeSeparators(sBackupPath));
+ return false;
+ }
+ if(pError != nullptr) {
+ *pError = exporterText(
+ "Unable to publish the completed video file.");
+ }
+ return false;
+ }
+ if(QFile::rename(sTemporaryPath, sTargetPath)) {
+ return true;
+ }
+ if(pError != nullptr) {
+ *pError = exporterText(
+ "Unable to publish the completed video file.");
+ }
+ return false;
+#endif
+}
+
+bool addLayerOrDelete(nmVTKScene& oScene, nmVTKRenderLayer* pLayer)
+{
+ // addLayer成功后Scene取得所有权;失败时仍由调用侧负责销毁。
+ if(pLayer != nullptr && oScene.addLayer(pLayer)) {
+ return true;
+ }
+ delete pLayer;
+ return false;
+}
+
+class OffscreenRenderWindowGuard
+{
+public:
+ OffscreenRenderWindowGuard(vtkRenderWindow* pRenderWindow,
+ vtkRenderer* pRenderer)
+ : m_pRenderWindow(pRenderWindow),
+ m_pRenderer(pRenderer)
+ {
+ }
+
+ ~OffscreenRenderWindowGuard()
+ {
+ if(m_pRenderWindow != nullptr) {
+ if(m_pRenderer != nullptr) {
+ m_pRenderWindow->RemoveRenderer(m_pRenderer);
+ }
+ m_pRenderWindow->Finalize();
+ }
+ }
+
+private:
+ vtkRenderWindow* m_pRenderWindow;
+ vtkRenderer* m_pRenderer;
+};
+
+}
+
+nmPebiResultAnimationExporter::Request::Request()
+ : m_bScalarBarVisible(true),
+ m_bScaleGridVisible(false),
+ m_bWellNamesVisible(true),
+ m_bGradientBackground(false),
+ m_pCamera(nullptr)
+{
+ m_dBackground[0] = m_dBackground[1] = m_dBackground[2] = 0.0;
+ m_dBackground2[0] = m_dBackground2[1] = m_dBackground2[2] = 0.0;
+}
+
+nmPebiResultAnimationExporter::nmPebiResultAnimationExporter(
+ QObject* pParent)
+ : QObject(pParent),
+ m_bCancelRequested(false)
+{
+}
+
+nmPebiResultAnimationExporter::~nmPebiResultAnimationExporter()
+{
+}
+
+nmPebiResultAnimationExporter::ExportResult
+nmPebiResultAnimationExporter::exportAnimation(
+ const Request& oRequest,
+ QString* pError)
+{
+ if(pError != nullptr) {
+ pError->clear();
+ }
+ m_bCancelRequested = false;
+ const int nAvailableFrameCount = oRequest.m_pSnapshot.isNull()
+ ? 0 : oRequest.m_pSnapshot->getPropertyFrameCount(
+ oRequest.m_sPropertyId);
+ nmPebiResultPropertyDescriptor oDescriptor;
+ if(oRequest.m_pSnapshot.isNull() ||
+ !oRequest.m_pSnapshot->isComplete() ||
+ !nmPebiResultPropertyCatalog::findDescriptor(
+ oRequest.m_sPropertyId, oDescriptor) ||
+ oDescriptor.m_eTimeType != NM_PebiResultProperty_Dynamic ||
+ oDescriptor.m_eAssociation !=
+ NM_PebiResultPropertyAssociation_CellData ||
+ !oRequest.m_oExportSettings.isValid(nAvailableFrameCount) ||
+ oRequest.m_sTargetFilePath.isEmpty() ||
+ oRequest.m_pCamera == nullptr) {
+ if(pError != nullptr) {
+ *pError = exporterText("The animation export request is invalid.");
+ }
+ return Export_Failed;
+ }
+
+ const QString sExtension = QFileInfo(
+ oRequest.m_sTargetFilePath).suffix().toLower();
+ if(!nmFFmpegVideoWriter::isSupportedExtension(sExtension)) {
+ if(pError != nullptr) {
+ *pError = exporterText("The selected video format is unsupported.");
+ }
+ return Export_Failed;
+ }
+
+ // 屏幕场景与离屏场景共用同一构造器,避免颜色规则出现两套实现。
+ nmPebiResultDisplayState oDisplayState;
+ if(!nmPebiResultDisplayStateBuilder::build(
+ oRequest.m_pSnapshot, oRequest.m_sPropertyId,
+ oRequest.m_oDisplaySettings, oDisplayState, pError)) {
+ return Export_Failed;
+ }
+
+ const QVector vecFrameIndices =
+ oRequest.m_oExportSettings.buildFrameIndices();
+ // 复制属性数组后逐帧更新,导出过程不会切换屏幕Scene中的当前帧。
+ nmPebiResultSnapshotRenderAdapter oAdapter;
+ if(vecFrameIndices.isEmpty() ||
+ !oAdapter.initialize(
+ oRequest.m_pSnapshot,
+ nmPebiResultSnapshotRenderAdapter::CopiedPropertyArray) ||
+ !oAdapter.setPropertyFrame(
+ oRequest.m_sPropertyId, vecFrameIndices.first())) {
+ if(pError != nullptr) {
+ *pError = exporterText("Unable to prepare the animation result data.");
+ }
+ return Export_Failed;
+ }
+
+ double dBounds[6] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+ if(!getAdapterBounds(
+ oAdapter, oRequest.m_pSnapshot->getResultCellCount(), dBounds)) {
+ if(pError != nullptr) {
+ *pError = exporterText("The animation render data failed validation.");
+ }
+ return Export_Failed;
+ }
+
+ vtkSmartPointer pRenderer =
+ vtkSmartPointer::New();
+ vtkSmartPointer pRenderWindow =
+ vtkSmartPointer::New();
+ pRenderWindow->OffScreenRenderingOn();
+ pRenderWindow->SetSize(
+ oRequest.m_oExportSettings.m_nOutputWidth,
+ oRequest.m_oExportSettings.m_nOutputHeight);
+ pRenderWindow->AddRenderer(pRenderer);
+ OffscreenRenderWindowGuard oRenderWindowGuard(
+ pRenderWindow, pRenderer);
+ pRenderer->SetBackground(
+ oRequest.m_dBackground[0],
+ oRequest.m_dBackground[1],
+ oRequest.m_dBackground[2]);
+ pRenderer->SetBackground2(
+ oRequest.m_dBackground2[0],
+ oRequest.m_dBackground2[1],
+ oRequest.m_dBackground2[2]);
+ pRenderer->SetGradientBackground(
+ oRequest.m_bGradientBackground ? 1 : 0);
+ // 保留用户视角;后续只更新ClippingRange,不执行ResetCamera适应窗口。
+ pRenderer->GetActiveCamera()->DeepCopy(oRequest.m_pCamera);
+
+ nmVTKScene oScene(pRenderer);
+ nmVTKMeshLayer* pMeshLayer = new nmVTKMeshLayer(
+ QString::fromLatin1(EXPORT_MESH_LAYER_ID));
+ pMeshLayer->setDisplayMode(
+ nmVTKMeshLayer::DisplayMode_SurfaceWithEdges);
+ pMeshLayer->getActor()->GetProperty()->SetEdgeColor(0.0, 0.0, 0.0);
+ pMeshLayer->getActor()->GetProperty()->LightingOff();
+ if(!pMeshLayer->setInputConnection(
+ oAdapter.getOutputPort(),
+ oAdapter.getCurrentScalarArrayName(),
+ nmVTKMeshLayer::ScalarAssociation_CellData,
+ oDisplayState.m_pLookupTable)) {
+ delete pMeshLayer;
+ if(pError != nullptr) {
+ *pError = exporterText("Unable to create the animation mesh layer.");
+ }
+ return Export_Failed;
+ }
+ pMeshLayer->setScalarVisibility(true);
+ pMeshLayer->setVisible(true);
+ if(!addLayerOrDelete(oScene, pMeshLayer)) {
+ if(pError != nullptr) {
+ *pError = exporterText("Unable to create the animation mesh layer.");
+ }
+ return Export_Failed;
+ }
+
+ nmVTKScalarBarLayer* pScalarBarLayer = new nmVTKScalarBarLayer(
+ QString::fromLatin1(EXPORT_SCALAR_BAR_LAYER_ID));
+ pScalarBarLayer->setLookupTable(oDisplayState.m_pLookupTable);
+ pScalarBarLayer->setTitle(oDisplayState.m_sScalarBarTitle);
+ pScalarBarLayer->setLabelFormat(QString::fromLatin1("%.4g"));
+ pScalarBarLayer->setViewportSize(
+ oRequest.m_oExportSettings.m_nOutputWidth,
+ oRequest.m_oExportSettings.m_nOutputHeight);
+ pScalarBarLayer->setNumberOfLabels(
+ oDisplayState.m_bSingleValueMode
+ ? 0 : pScalarBarLayer->getResponsiveLabelCount());
+ pScalarBarLayer->setConstantValueLabel(
+ oDisplayState.m_bSingleValueMode,
+ oDisplayState.m_bSingleValueMode
+ ? QString::number(
+ oDisplayState.m_dBusinessRange[0], 'g', 6)
+ : QString());
+ pScalarBarLayer->setVisible(oRequest.m_bScalarBarVisible);
+ if(!addLayerOrDelete(oScene, pScalarBarLayer)) {
+ if(pError != nullptr) {
+ *pError = exporterText("Unable to create the animation scalar bar.");
+ }
+ return Export_Failed;
+ }
+
+ nmVTKPlanarScaleGridLayer* pScaleGridLayer =
+ new nmVTKPlanarScaleGridLayer(
+ QString::fromLatin1(EXPORT_SCALE_GRID_LAYER_ID));
+ if(!pScaleGridLayer->setBounds(
+ dBounds[0], dBounds[1], dBounds[2], dBounds[3], dBounds[4])) {
+ delete pScaleGridLayer;
+ if(pError != nullptr) {
+ *pError = exporterText("Unable to create the animation scale grid.");
+ }
+ return Export_Failed;
+ }
+ pScaleGridLayer->setVisible(oRequest.m_bScaleGridVisible);
+ if(!addLayerOrDelete(oScene, pScaleGridLayer)) {
+ if(pError != nullptr) {
+ *pError = exporterText("Unable to create the animation scale grid.");
+ }
+ return Export_Failed;
+ }
+
+ nmPebiResultWellAnnotationLayer* pWellLayer =
+ new nmPebiResultWellAnnotationLayer(
+ QString::fromLatin1(EXPORT_WELLS_LAYER_ID));
+ if(!pWellLayer->prepareCandidate(oRequest.m_pSnapshot)) {
+ delete pWellLayer;
+ if(pError != nullptr) {
+ *pError = exporterText("Unable to create the animation well annotations.");
+ }
+ return Export_Failed;
+ }
+ pWellLayer->commitCandidate();
+ pWellLayer->setVisible(oRequest.m_bWellNamesVisible);
+ if(!addLayerOrDelete(oScene, pWellLayer)) {
+ if(pError != nullptr) {
+ *pError = exporterText("Unable to create the animation well annotations.");
+ }
+ return Export_Failed;
+ }
+
+ pRenderer->ResetCameraClippingRange(dBounds);
+
+ const QString sTemporaryPath = createTemporaryPath(
+ oRequest.m_sTargetFilePath);
+ nmFFmpegVideoWriter::VideoSettings oVideoSettings;
+ oVideoSettings.m_sTemporaryFilePath = sTemporaryPath;
+ oVideoSettings.m_sFileExtension = sExtension;
+ oVideoSettings.m_nWidth =
+ oRequest.m_oExportSettings.m_nOutputWidth;
+ oVideoSettings.m_nHeight =
+ oRequest.m_oExportSettings.m_nOutputHeight;
+ oVideoSettings.m_nFramesPerSecond =
+ oRequest.m_oExportSettings.m_nFramesPerSecond;
+ nmFFmpegVideoWriter oWriter;
+ if(!oWriter.open(oVideoSettings, pError)) {
+ return Export_Failed;
+ }
+
+ vtkSmartPointer pCapture =
+ vtkSmartPointer::New();
+ pCapture->SetInput(pRenderWindow);
+ pCapture->SetInputBufferTypeToRGB();
+ pCapture->ReadFrontBufferOff();
+ pCapture->ShouldRerenderOff();
+ emit progressChanged(0, vecFrameIndices.size());
+ QCoreApplication::processEvents(QEventLoop::AllEvents);
+ if(m_bCancelRequested) {
+ oWriter.cancel();
+ return Export_Cancelled;
+ }
+
+ for(int nOutputIndex = 0;
+ nOutputIndex < vecFrameIndices.size(); ++nOutputIndex) {
+ if(!oAdapter.setPropertyFrame(
+ oRequest.m_sPropertyId, vecFrameIndices[nOutputIndex])) {
+ oWriter.cancel();
+ if(pError != nullptr) {
+ *pError = exporterText("Unable to load an animation frame.");
+ }
+ return Export_Failed;
+ }
+
+ pRenderWindow->Render();
+ pCapture->Modified();
+ pCapture->Update();
+ vtkImageData* pImage = pCapture->GetOutput();
+ int pDimensions[3] = { 0, 0, 0 };
+ vtkIdType pIncrements[3] = { 0, 0, 0 };
+ if(pImage != nullptr) {
+ pImage->GetDimensions(pDimensions);
+ pImage->GetIncrements(pIncrements);
+ }
+ unsigned char* pPixels = pImage == nullptr ? nullptr :
+ static_cast(pImage->GetScalarPointer());
+ if(pImage == nullptr || pPixels == nullptr ||
+ pImage->GetScalarType() != VTK_UNSIGNED_CHAR ||
+ pImage->GetNumberOfScalarComponents() != 3 ||
+ pDimensions[0] != oVideoSettings.m_nWidth ||
+ pDimensions[1] != oVideoSettings.m_nHeight ||
+ pIncrements[1] < oVideoSettings.m_nWidth * 3 ||
+ pIncrements[1] > INT_MAX ||
+ !oWriter.writeRgb24Frame(
+ pPixels, static_cast(pIncrements[1]), true, pError)) {
+ oWriter.cancel();
+ if(pError != nullptr && pError->isEmpty()) {
+ *pError = exporterText("Unable to capture an animation frame.");
+ }
+ return Export_Failed;
+ }
+
+ // 单帧完成编码后再处理事件,避免取消或其他事件造成半帧状态。
+ emit progressChanged(nOutputIndex + 1, vecFrameIndices.size());
+ QCoreApplication::processEvents(QEventLoop::AllEvents);
+ if(m_bCancelRequested) {
+ oWriter.cancel();
+ return Export_Cancelled;
+ }
+ }
+
+ // Writer只负责完成临时视频;成功后再单独发布到用户目标路径。
+ if(!oWriter.finish(pError)) {
+ return Export_Failed;
+ }
+ if(!publishTemporaryFile(
+ sTemporaryPath, oRequest.m_sTargetFilePath, pError)) {
+ QFile::remove(sTemporaryPath);
+ if(pError != nullptr && pError->isEmpty()) {
+ *pError = exporterText("Unable to publish the completed video file.");
+ }
+ return Export_Failed;
+ }
+ return Export_Succeeded;
+}
+
+void nmPebiResultAnimationExporter::cancel()
+{
+ m_bCancelRequested = true;
+}
diff --git a/Src/nmNum/nmSubWxs/nmPebiResultDisplayStateBuilder.cpp b/Src/nmNum/nmSubWxs/nmPebiResultDisplayStateBuilder.cpp
new file mode 100644
index 00000000..bb715a3f
--- /dev/null
+++ b/Src/nmNum/nmSubWxs/nmPebiResultDisplayStateBuilder.cpp
@@ -0,0 +1,231 @@
+#include "nmPebiResultDisplayStateBuilder.h"
+
+#include "nmPebiResultPropertyDisplayText.h"
+#include "nmPebiResultSnapshot.h"
+#include "nmVTKColorMapCatalog.h"
+
+#include
+#include
+
+#include
+#include
+
+#include
+
+namespace {
+
+QString displayStateText(const char* pText)
+{
+ // 沿用原 SceneController 翻译上下文,避免迁移既有 TS 条目。
+ return QCoreApplication::translate(
+ "nmPebiResultSceneController", pText);
+}
+
+bool getInternalDisplayRange(const double dVisibleRange[2],
+ bool bLogarithmic,
+ bool bSingleValueMode,
+ double dInternalRange[2])
+{
+ if(dVisibleRange == nullptr || dInternalRange == nullptr ||
+ !vtkMath::IsFinite(dVisibleRange[0]) ||
+ !vtkMath::IsFinite(dVisibleRange[1]) ||
+ dVisibleRange[0] > dVisibleRange[1] ||
+ (bLogarithmic && dVisibleRange[0] <= 0.0)) {
+ return false;
+ }
+
+ if(dVisibleRange[0] < dVisibleRange[1]) {
+ dInternalRange[0] = dVisibleRange[0];
+ dInternalRange[1] = dVisibleRange[1];
+ return true;
+ }
+ if(!bSingleValueMode || dVisibleRange[0] != dVisibleRange[1]) {
+ return false;
+ }
+
+ // VTK要求映射范围严格递增;微量扩展只供内部映射,不改变业务值。
+ const double dValue = dVisibleRange[0];
+ double dMaximum = 0.0;
+ if(bLogarithmic) {
+ dMaximum = dValue * (1.0 + 1.0e-6);
+ if(!vtkMath::IsFinite(dMaximum) || dMaximum <= dValue) {
+ dMaximum = dValue * 2.0;
+ }
+ } else {
+ const double dEpsilon = qMax(1.0, fabs(dValue)) * 1.0e-6;
+ dMaximum = dValue + dEpsilon;
+ }
+ if(!vtkMath::IsFinite(dMaximum) || dValue >= dMaximum ||
+ (bLogarithmic && dValue <= 0.0)) {
+ return false;
+ }
+ dInternalRange[0] = dValue;
+ dInternalRange[1] = dMaximum;
+ return true;
+}
+
+bool fillLookupTableWithFirstColor(vtkLookupTable* pLookupTable)
+{
+ if(pLookupTable == nullptr ||
+ pLookupTable->GetNumberOfTableValues() <= 0) {
+ return false;
+ }
+
+ double dFirstColor[4] = { 0.0, 0.0, 0.0, 1.0 };
+ pLookupTable->GetTableValue(0, dFirstColor);
+ for(int nComponent = 0; nComponent < 4; ++nComponent) {
+ if(!vtkMath::IsFinite(dFirstColor[nComponent])) {
+ return false;
+ }
+ }
+
+ const int nTableValueCount = static_cast(
+ pLookupTable->GetNumberOfTableValues());
+ for(int nIndex = 0; nIndex < nTableValueCount; ++nIndex) {
+ pLookupTable->SetTableValue(nIndex, dFirstColor);
+ }
+ return true;
+}
+
+}
+
+nmPebiResultDisplayState::nmPebiResultDisplayState()
+ : m_pLookupTable(nullptr),
+ m_bSingleValueMode(false)
+{
+ m_dBusinessRange[0] = m_dBusinessRange[1] = 0.0;
+ m_dVisibleRange[0] = m_dVisibleRange[1] = 0.0;
+ m_dInternalRange[0] = 0.0;
+ m_dInternalRange[1] = 1.0;
+}
+
+bool nmPebiResultDisplayStateBuilder::build(
+ const QSharedPointer& pSnapshot,
+ const QString& sPropertyId,
+ const nmPebiResultDisplaySettings& oRequestedSettings,
+ nmPebiResultDisplayState& oState,
+ QString* pError)
+{
+ if(pError != nullptr) {
+ pError->clear();
+ }
+ nmPebiResultDisplaySettings oSettings =
+ oRequestedSettings.normalized();
+ if(pSnapshot.isNull() || !pSnapshot->hasProperty(sPropertyId) ||
+ !oSettings.isStructurallyValid()) {
+ if(pError != nullptr) {
+ *pError = displayStateText("The color settings are invalid.");
+ }
+ return false;
+ }
+ if(!nmVTKColorMapCatalog::contains(oSettings.m_sColorMapId)) {
+ if(pError != nullptr) {
+ *pError = displayStateText(
+ "The selected color map is unavailable.");
+ }
+ return false;
+ }
+
+ double dBusinessRange[2] = { 0.0, 0.0 };
+ if(!pSnapshot->getPropertyRange(sPropertyId, dBusinessRange) ||
+ !vtkMath::IsFinite(dBusinessRange[0]) ||
+ !vtkMath::IsFinite(dBusinessRange[1]) ||
+ dBusinessRange[0] > dBusinessRange[1]) {
+ if(pError != nullptr) {
+ *pError = displayStateText(
+ "The result property range is invalid.");
+ }
+ return false;
+ }
+
+ double dVisibleRange[2] = {
+ dBusinessRange[0], dBusinessRange[1]
+ };
+ if(oSettings.m_bHasManualRange) {
+ if(!vtkMath::IsFinite(oSettings.m_dManualMinimum) ||
+ !vtkMath::IsFinite(oSettings.m_dManualMaximum) ||
+ oSettings.m_dManualMinimum >= oSettings.m_dManualMaximum) {
+ if(pError != nullptr) {
+ *pError = displayStateText(
+ "The manual range must contain two finite increasing values.");
+ }
+ return false;
+ }
+ dVisibleRange[0] = oSettings.m_dManualMinimum;
+ dVisibleRange[1] = oSettings.m_dManualMaximum;
+ }
+
+ const bool bSingleValueMode =
+ !oSettings.m_bHasManualRange &&
+ dBusinessRange[0] == dBusinessRange[1];
+ const bool bLogarithmic =
+ oSettings.m_eScaleMode == NM_PebiColorScale_Logarithmic;
+ if(bLogarithmic &&
+ (dBusinessRange[0] <= 0.0 || dVisibleRange[0] <= 0.0)) {
+ if(pError != nullptr) {
+ *pError = displayStateText(
+ "Logarithmic scale requires positive property and display ranges.");
+ }
+ return false;
+ }
+
+ double dInternalRange[2] = { 0.0, 1.0 };
+ vtkSmartPointer pLookupTable =
+ nmVTKColorMapCatalog::createLookupTable(
+ oSettings.m_sColorMapId);
+ if(pLookupTable == nullptr ||
+ !getInternalDisplayRange(dVisibleRange, bLogarithmic,
+ bSingleValueMode, dInternalRange)) {
+ if(pError != nullptr) {
+ *pError = displayStateText(
+ "Unable to construct the color mapping.");
+ }
+ return false;
+ }
+
+ pLookupTable->SetTableRange(dInternalRange);
+ if(bLogarithmic) {
+ pLookupTable->SetScaleToLog10();
+ } else {
+ pLookupTable->SetScaleToLinear();
+ }
+ // 单值自动范围固定到色带第0色,特殊越界色随后单独构造。
+ if(bSingleValueMode &&
+ !fillLookupTableWithFirstColor(pLookupTable)) {
+ if(pError != nullptr) {
+ *pError = displayStateText(
+ "Unable to construct the color mapping.");
+ }
+ return false;
+ }
+
+ const QColor oBelowColor = oSettings.m_oBelowRangeColor;
+ const QColor oAboveColor = oSettings.m_oAboveRangeColor;
+ pLookupTable->SetBelowRangeColor(
+ oBelowColor.redF(), oBelowColor.greenF(),
+ oBelowColor.blueF(), 1.0);
+ pLookupTable->SetAboveRangeColor(
+ oAboveColor.redF(), oAboveColor.greenF(),
+ oAboveColor.blueF(), 1.0);
+ pLookupTable->SetUseBelowRangeColor(
+ oSettings.m_bUseBelowRangeColor ? 1 : 0);
+ pLookupTable->SetUseAboveRangeColor(
+ oSettings.m_bUseAboveRangeColor ? 1 : 0);
+ pLookupTable->BuildSpecialColors();
+ pLookupTable->IndexedLookupOff();
+ pLookupTable->ResetAnnotations();
+
+ oState.m_oSettings = oSettings;
+ oState.m_dBusinessRange[0] = dBusinessRange[0];
+ oState.m_dBusinessRange[1] = dBusinessRange[1];
+ oState.m_dVisibleRange[0] = dVisibleRange[0];
+ oState.m_dVisibleRange[1] = dVisibleRange[1];
+ oState.m_dInternalRange[0] = dInternalRange[0];
+ oState.m_dInternalRange[1] = dInternalRange[1];
+ oState.m_pLookupTable = pLookupTable;
+ oState.m_sScalarBarTitle =
+ nmPebiResultPropertyDisplayText::getScalarBarTitle(
+ sPropertyId, bLogarithmic);
+ oState.m_bSingleValueMode = bSingleValueMode;
+ return true;
+}
diff --git a/Src/nmNum/nmSubWxs/nmPebiResultSceneController.cpp b/Src/nmNum/nmSubWxs/nmPebiResultSceneController.cpp
index 347d251c..29ece80f 100644
--- a/Src/nmNum/nmSubWxs/nmPebiResultSceneController.cpp
+++ b/Src/nmNum/nmSubWxs/nmPebiResultSceneController.cpp
@@ -1,12 +1,11 @@
#include "nmPebiResultSceneController.h"
+#include "nmPebiResultDisplayStateBuilder.h"
#include "nmPebiResultPropertyCatalog.h"
-#include "nmPebiResultPropertyDisplayText.h"
#include "nmPebiResultSnapshot.h"
#include "nmPebiResultSnapshotRenderAdapter.h"
#include "nmPebiResultWellAnnotationLayer.h"
-#include "nmVTKColorMapCatalog.h"
#include "nmVTKMeshLayer.h"
#include "nmVTKPlanarScaleGridLayer.h"
#include "nmVTKScalarBarLayer.h"
@@ -29,8 +28,6 @@
#include
#include
-#include
-
namespace {
const char* const RESULT_MESH_LAYER_ID = "pebi.result.mesh";
@@ -115,221 +112,6 @@ bool getFiniteBounds(vtkDataSet* pDataSet, double dBounds[6])
dBounds[4] <= dBounds[5];
}
-bool getInternalDisplayRange(const double dVisibleRange[2],
- bool bLogarithmic,
- bool bSingleValueMode,
- double dInternalRange[2])
-{
- if(dVisibleRange == nullptr || dInternalRange == nullptr ||
- !vtkMath::IsFinite(dVisibleRange[0]) ||
- !vtkMath::IsFinite(dVisibleRange[1]) ||
- dVisibleRange[0] > dVisibleRange[1] ||
- (bLogarithmic && dVisibleRange[0] <= 0.0)) {
- return false;
- }
-
- if(dVisibleRange[0] < dVisibleRange[1]) {
- dInternalRange[0] = dVisibleRange[0];
- dInternalRange[1] = dVisibleRange[1];
- return true;
- }
- if(!bSingleValueMode || dVisibleRange[0] != dVisibleRange[1]) {
- return false;
- }
-
- // VTK 不接受零宽范围。单值模式从真实值单向扩展,使 c 位于 LUT 最小端。
- const double dValue = dVisibleRange[0];
- double dMaximum = 0.0;
- if(bLogarithmic) {
- dMaximum = dValue * (1.0 + 1.0e-6);
- if(!vtkMath::IsFinite(dMaximum) || dMaximum <= dValue) {
- dMaximum = dValue * 2.0;
- }
- } else {
- const double dEpsilon = qMax(1.0, fabs(dValue)) * 1.0e-6;
- dMaximum = dValue + dEpsilon;
- }
- if(!vtkMath::IsFinite(dMaximum) || dValue >= dMaximum ||
- (bLogarithmic && dValue <= 0.0)) {
- return false;
- }
- dInternalRange[0] = dValue;
- dInternalRange[1] = dMaximum;
- return true;
-}
-
-bool fillLookupTableWithFirstColor(vtkLookupTable* pLookupTable)
-{
- if(pLookupTable == nullptr ||
- pLookupTable->GetNumberOfTableValues() <= 0) {
- return false;
- }
-
- // 保留用户选择的色带语义,但让单值网格和色标统一使用第 0 个普通表项。
- double dFirstColor[4] = { 0.0, 0.0, 0.0, 1.0 };
- pLookupTable->GetTableValue(0, dFirstColor);
- for(int nComponent = 0; nComponent < 4; ++nComponent) {
- if(!vtkMath::IsFinite(dFirstColor[nComponent])) {
- return false;
- }
- }
-
- const int nTableValueCount = static_cast(
- pLookupTable->GetNumberOfTableValues());
- for(int nIndex = 0; nIndex < nTableValueCount; ++nIndex) {
- pLookupTable->SetTableValue(nIndex, dFirstColor);
- }
- return true;
-}
-
-struct ResultDisplayCandidate
-{
- ResultDisplayCandidate()
- : m_pLookupTable(nullptr),
- m_bSingleValueMode(false)
- {
- m_dBusinessRange[0] = m_dBusinessRange[1] = 0.0;
- m_dVisibleRange[0] = m_dVisibleRange[1] = 0.0;
- m_dInternalRange[0] = 0.0;
- m_dInternalRange[1] = 1.0;
- }
-
- nmPebiResultDisplaySettings m_oSettings;
- double m_dBusinessRange[2];
- double m_dVisibleRange[2];
- double m_dInternalRange[2];
- vtkSmartPointer m_pLookupTable;
- QString m_sScalarBarTitle;
- bool m_bSingleValueMode;
-};
-
-bool prepareDisplayCandidate(
- const QSharedPointer& pSnapshot,
- const QString& sPropertyId,
- const nmPebiResultDisplaySettings& oRequestedSettings,
- ResultDisplayCandidate& oCandidate,
- QString* pError)
-{
- nmPebiResultDisplaySettings oSettings = oRequestedSettings.normalized();
- if(pSnapshot.isNull() || !pSnapshot->hasProperty(sPropertyId) ||
- !oSettings.isStructurallyValid()) {
- if(pError != nullptr) {
- *pError = controllerText("The color settings are invalid.");
- }
- return false;
- }
- if(!nmVTKColorMapCatalog::contains(oSettings.m_sColorMapId)) {
- if(pError != nullptr) {
- *pError = controllerText("The selected color map is unavailable.");
- }
- return false;
- }
-
- double dBusinessRange[2] = { 0.0, 0.0 };
- if(!pSnapshot->getPropertyRange(sPropertyId, dBusinessRange) ||
- !vtkMath::IsFinite(dBusinessRange[0]) ||
- !vtkMath::IsFinite(dBusinessRange[1]) ||
- dBusinessRange[0] > dBusinessRange[1]) {
- if(pError != nullptr) {
- *pError = controllerText("The result property range is invalid.");
- }
- return false;
- }
-
- double dVisibleRange[2] = {
- dBusinessRange[0], dBusinessRange[1]
- };
- if(oSettings.m_bHasManualRange) {
- if(!vtkMath::IsFinite(oSettings.m_dManualMinimum) ||
- !vtkMath::IsFinite(oSettings.m_dManualMaximum) ||
- oSettings.m_dManualMinimum >= oSettings.m_dManualMaximum) {
- if(pError != nullptr) {
- *pError = controllerText(
- "The manual range must contain two finite increasing values.");
- }
- return false;
- }
- dVisibleRange[0] = oSettings.m_dManualMinimum;
- dVisibleRange[1] = oSettings.m_dManualMaximum;
- }
-
- const bool bSingleValueMode =
- !oSettings.m_bHasManualRange &&
- dBusinessRange[0] == dBusinessRange[1];
-
- const bool bLogarithmic =
- oSettings.m_eScaleMode == NM_PebiColorScale_Logarithmic;
- if(bLogarithmic &&
- (dBusinessRange[0] <= 0.0 || dVisibleRange[0] <= 0.0)) {
- if(pError != nullptr) {
- *pError = controllerText(
- "Logarithmic scale requires positive property and display ranges.");
- }
- return false;
- }
-
- double dInternalRange[2] = { 0.0, 1.0 };
- vtkSmartPointer pLookupTable =
- nmVTKColorMapCatalog::createLookupTable(
- oSettings.m_sColorMapId);
- if(pLookupTable == nullptr ||
- !getInternalDisplayRange(dVisibleRange, bLogarithmic,
- bSingleValueMode,
- dInternalRange)) {
- if(pError != nullptr) {
- *pError = controllerText("Unable to construct the color mapping.");
- }
- return false;
- }
-
- pLookupTable->SetTableRange(dInternalRange);
- if(bLogarithmic) {
- pLookupTable->SetScaleToLog10();
- } else {
- pLookupTable->SetScaleToLinear();
- }
- if(bSingleValueMode &&
- !fillLookupTableWithFirstColor(pLookupTable)) {
- if(pError != nullptr) {
- *pError = controllerText("Unable to construct the color mapping.");
- }
- return false;
- }
- const QColor oBelowColor = oSettings.m_oBelowRangeColor;
- const QColor oAboveColor = oSettings.m_oAboveRangeColor;
- pLookupTable->SetBelowRangeColor(
- oBelowColor.redF(), oBelowColor.greenF(),
- oBelowColor.blueF(), 1.0);
- pLookupTable->SetAboveRangeColor(
- oAboveColor.redF(), oAboveColor.greenF(),
- oAboveColor.blueF(), 1.0);
- pLookupTable->SetUseBelowRangeColor(
- oSettings.m_bUseBelowRangeColor ? 1 : 0);
- pLookupTable->SetUseAboveRangeColor(
- oSettings.m_bUseAboveRangeColor ? 1 : 0);
- // VTK 7.1 的上下越界颜色位于特殊表项中,Setter 后必须显式同步。
- // 不能使用 ForceBuild,否则会覆盖色带目录手工写入的 256 个颜色表项。
- pLookupTable->BuildSpecialColors();
- pLookupTable->IndexedLookupOff();
- pLookupTable->ResetAnnotations();
-
- const QString sTitle =
- nmPebiResultPropertyDisplayText::getScalarBarTitle(
- sPropertyId, bLogarithmic);
-
- oCandidate.m_oSettings = oSettings;
- oCandidate.m_dBusinessRange[0] = dBusinessRange[0];
- oCandidate.m_dBusinessRange[1] = dBusinessRange[1];
- oCandidate.m_dVisibleRange[0] = dVisibleRange[0];
- oCandidate.m_dVisibleRange[1] = dVisibleRange[1];
- oCandidate.m_dInternalRange[0] = dInternalRange[0];
- oCandidate.m_dInternalRange[1] = dInternalRange[1];
- oCandidate.m_pLookupTable = pLookupTable;
- oCandidate.m_sScalarBarTitle = sTitle;
- oCandidate.m_bSingleValueMode = bSingleValueMode;
- return true;
-}
-
QString chooseInitialProperty(
const QSharedPointer& pSnapshot)
{
@@ -710,7 +492,7 @@ public:
m_pScalarBarLayer->setNumberOfLabels(nLabelCount);
}
- void applyScalarBarState(const ResultDisplayCandidate& oDisplay)
+ void applyScalarBarState(const nmPebiResultDisplayState& oDisplay)
{
if(m_pScalarBarLayer == nullptr) {
return;
@@ -1022,8 +804,8 @@ bool nmPebiResultSceneController::setSnapshot(
mapCandidateSettings.insert(sPropertyId, oSettings);
// 在触碰活动 Scene 前预检每个可用属性,避免隐藏的无效偏好延迟到切换时。
- ResultDisplayCandidate oPropertyDisplayCandidate;
- if(!prepareDisplayCandidate(
+ nmPebiResultDisplayState oPropertyDisplayCandidate;
+ if(!nmPebiResultDisplayStateBuilder::build(
pSnapshot, sPropertyId, oSettings,
oPropertyDisplayCandidate, &sDisplayError)) {
delete pCandidateAdapter;
@@ -1034,8 +816,8 @@ bool nmPebiResultSceneController::setSnapshot(
}
}
- ResultDisplayCandidate oDisplayCandidate;
- if(!prepareDisplayCandidate(
+ nmPebiResultDisplayState oDisplayCandidate;
+ if(!nmPebiResultDisplayStateBuilder::build(
pSnapshot, sInitialProperty,
mapCandidateSettings.value(sInitialProperty),
oDisplayCandidate, &sDisplayError)) {
@@ -1229,8 +1011,8 @@ bool nmPebiResultSceneController::applyPropertyFrame(
const nmPebiResultDisplaySettings oTargetSettings =
m_pPrivate->m_mapDisplaySettings.value(
sPropertyId, nmPebiResultDisplaySettings());
- ResultDisplayCandidate oDisplayCandidate;
- if(!prepareDisplayCandidate(
+ nmPebiResultDisplayState oDisplayCandidate;
+ if(!nmPebiResultDisplayStateBuilder::build(
m_pPrivate->m_pSnapshot, sPropertyId, oTargetSettings,
oDisplayCandidate, pError)) {
return false;
@@ -1315,8 +1097,8 @@ bool nmPebiResultSceneController::applyCurrentDisplaySettings(
return false;
}
- ResultDisplayCandidate oDisplayCandidate;
- if(!prepareDisplayCandidate(
+ nmPebiResultDisplayState oDisplayCandidate;
+ if(!nmPebiResultDisplayStateBuilder::build(
m_pPrivate->m_pSnapshot,
sExpectedPropertyId,
oSettings,
diff --git a/Src/nmNum/nmSubWxs/nmWxPebiResultAnimationExportDlg.cpp b/Src/nmNum/nmSubWxs/nmWxPebiResultAnimationExportDlg.cpp
new file mode 100644
index 00000000..c0fa047f
--- /dev/null
+++ b/Src/nmNum/nmSubWxs/nmWxPebiResultAnimationExportDlg.cpp
@@ -0,0 +1,300 @@
+#include "nmWxPebiResultAnimationExportDlg.h"
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+namespace {
+
+QString exportDialogIconPath(const QString& sFileName)
+{
+ const QString sApplicationDir = QCoreApplication::applicationDirPath();
+ return sApplicationDir.section('/', 0, -2) +
+ "/Res/Icon/" + sFileName;
+}
+
+}
+
+nmWxPebiResultAnimationExportDlg::nmWxPebiResultAnimationExportDlg(
+ const QVector& vecFrameTimesHours,
+ const QSize& oCurrentViewportSize,
+ QWidget* pParent)
+ : QDialog(pParent),
+ m_vecFrameTimesHours(vecFrameTimesHours),
+ m_oCurrentViewportSize(oCurrentViewportSize),
+ m_pFpsSpinBox(nullptr),
+ m_pStartFrameCombo(nullptr),
+ m_pEndFrameCombo(nullptr),
+ m_pSamplingIntervalSpinBox(nullptr),
+ m_pResolutionCombo(nullptr),
+ m_pWidthSpinBox(nullptr),
+ m_pHeightSpinBox(nullptr),
+ m_pOutputFrameCountLabel(nullptr),
+ m_pEstimatedDurationLabel(nullptr),
+ m_pErrorLabel(nullptr)
+{
+ createUi();
+ populateFrameItems();
+ onResolutionPresetChanged(m_pResolutionCombo->currentIndex());
+ onFrameRangeChanged();
+}
+
+nmPebiResultAnimationExportSettings
+nmWxPebiResultAnimationExportDlg::getSettings() const
+{
+ return m_oAcceptedSettings;
+}
+
+void nmWxPebiResultAnimationExportDlg::onFrameRangeChanged()
+{
+ const int nStartIndex = m_pStartFrameCombo->currentIndex();
+ if(nStartIndex >= 0 &&
+ m_pEndFrameCombo->currentIndex() < nStartIndex) {
+ const bool bBlocked = m_pEndFrameCombo->blockSignals(true);
+ m_pEndFrameCombo->setCurrentIndex(nStartIndex);
+ m_pEndFrameCombo->blockSignals(bBlocked);
+ }
+
+ const int nRangeLength = qMax(1,
+ m_pEndFrameCombo->currentIndex() -
+ m_pStartFrameCombo->currentIndex());
+ m_pSamplingIntervalSpinBox->setMaximum(nRangeLength);
+ updateSummary();
+}
+
+void nmWxPebiResultAnimationExportDlg::onResolutionPresetChanged(
+ int nIndex)
+{
+ Q_UNUSED(nIndex);
+ const ResolutionPreset ePreset = static_cast(
+ m_pResolutionCombo->itemData(
+ m_pResolutionCombo->currentIndex()).toInt());
+ int nWidth = m_oCurrentViewportSize.width();
+ int nHeight = m_oCurrentViewportSize.height();
+ if(ePreset == Resolution_720p) {
+ nWidth = 1280;
+ nHeight = 720;
+ } else if(ePreset == Resolution_1080p) {
+ nWidth = 1920;
+ nHeight = 1080;
+ }
+ if(nWidth <= 0 || nHeight <= 0) {
+ nWidth = 1280;
+ nHeight = 720;
+ }
+
+ const bool bCustom = ePreset == Resolution_Custom;
+ if(!bCustom) {
+ m_pWidthSpinBox->setValue(normalizeEvenDimension(nWidth));
+ m_pHeightSpinBox->setValue(normalizeEvenDimension(nHeight));
+ }
+ m_pWidthSpinBox->setEnabled(bCustom);
+ m_pHeightSpinBox->setEnabled(bCustom);
+ updateSummary();
+}
+
+void nmWxPebiResultAnimationExportDlg::normalizeCustomDimensions()
+{
+ // editingFinished后再回写,避免valueChanged期间干扰用户键盘输入。
+ m_pWidthSpinBox->setValue(
+ normalizeEvenDimension(m_pWidthSpinBox->value()));
+ m_pHeightSpinBox->setValue(
+ normalizeEvenDimension(m_pHeightSpinBox->value()));
+ updateSummary();
+}
+
+void nmWxPebiResultAnimationExportDlg::updateSummary()
+{
+ const nmPebiResultAnimationExportSettings oSettings =
+ collectSettings();
+ const int nOutputFrameCount = oSettings.getOutputFrameCount();
+ m_pOutputFrameCountLabel->setText(
+ QString::number(nOutputFrameCount));
+ const double dDuration = oSettings.m_nFramesPerSecond > 0
+ ? static_cast(nOutputFrameCount) /
+ static_cast(oSettings.m_nFramesPerSecond)
+ : 0.0;
+ m_pEstimatedDurationLabel->setText(
+ tr("%1 s").arg(QString::number(dDuration, 'g', 6)));
+ m_pErrorLabel->clear();
+}
+
+void nmWxPebiResultAnimationExportDlg::acceptSettings()
+{
+ // 接受前再规范化一次,覆盖按钮点击与焦点事件顺序差异。
+ normalizeCustomDimensions();
+ const nmPebiResultAnimationExportSettings oSettings =
+ collectSettings();
+ if(!oSettings.isValid(m_vecFrameTimesHours.size())) {
+ m_pErrorLabel->setText(
+ tr("The animation export settings are invalid."));
+ return;
+ }
+ m_oAcceptedSettings = oSettings;
+ accept();
+}
+
+void nmWxPebiResultAnimationExportDlg::createUi()
+{
+ setWindowTitle(tr("Export Animation"));
+ setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+ setMinimumWidth(430);
+
+ QVBoxLayout* pMainLayout = new QVBoxLayout(this);
+ pMainLayout->setContentsMargins(12, 10, 12, 10);
+ pMainLayout->setSpacing(8);
+
+ QGridLayout* pGrid = new QGridLayout();
+ pGrid->setHorizontalSpacing(8);
+ pGrid->setVerticalSpacing(6);
+ int nRow = 0;
+
+ m_pFpsSpinBox = new QSpinBox(this);
+ m_pFpsSpinBox->setRange(1, 5000);
+ m_pFpsSpinBox->setValue(15);
+ m_pFpsSpinBox->setSuffix(tr(" FPS"));
+ pGrid->addWidget(new QLabel(tr("Frame rate"), this), nRow, 0);
+ pGrid->addWidget(m_pFpsSpinBox, nRow++, 1, 1, 2);
+
+ m_pStartFrameCombo = new QComboBox(this);
+ pGrid->addWidget(new QLabel(tr("Start frame"), this), nRow, 0);
+ pGrid->addWidget(m_pStartFrameCombo, nRow++, 1, 1, 2);
+
+ m_pEndFrameCombo = new QComboBox(this);
+ pGrid->addWidget(new QLabel(tr("End frame"), this), nRow, 0);
+ pGrid->addWidget(m_pEndFrameCombo, nRow++, 1, 1, 2);
+
+ m_pSamplingIntervalSpinBox = new QSpinBox(this);
+ m_pSamplingIntervalSpinBox->setRange(1, 1);
+ pGrid->addWidget(new QLabel(tr("Sampling interval"), this), nRow, 0);
+ pGrid->addWidget(m_pSamplingIntervalSpinBox, nRow++, 1, 1, 2);
+
+ m_pResolutionCombo = new QComboBox(this);
+ m_pResolutionCombo->addItem(tr("Current view"), Resolution_CurrentView);
+ m_pResolutionCombo->addItem(QString::fromLatin1("1280 x 720"),
+ Resolution_720p);
+ m_pResolutionCombo->addItem(QString::fromLatin1("1920 x 1080"),
+ Resolution_1080p);
+ m_pResolutionCombo->addItem(tr("Custom"), Resolution_Custom);
+ pGrid->addWidget(new QLabel(tr("Resolution"), this), nRow, 0);
+ pGrid->addWidget(m_pResolutionCombo, nRow++, 1, 1, 2);
+
+ m_pWidthSpinBox = new QSpinBox(this);
+ m_pHeightSpinBox = new QSpinBox(this);
+ m_pWidthSpinBox->setRange(2, 8192);
+ m_pHeightSpinBox->setRange(2, 8192);
+ m_pWidthSpinBox->setSingleStep(2);
+ m_pHeightSpinBox->setSingleStep(2);
+ QHBoxLayout* pCustomSizeLayout = new QHBoxLayout();
+ pCustomSizeLayout->setContentsMargins(0, 0, 0, 0);
+ pCustomSizeLayout->setSpacing(6);
+ pCustomSizeLayout->addWidget(m_pWidthSpinBox);
+ pCustomSizeLayout->addWidget(new QLabel(QString::fromLatin1("x"), this));
+ pCustomSizeLayout->addWidget(m_pHeightSpinBox);
+ pGrid->addWidget(new QLabel(tr("Output size"), this), nRow, 0);
+ pGrid->addLayout(pCustomSizeLayout, nRow++, 1, 1, 2);
+
+ m_pOutputFrameCountLabel = new QLabel(this);
+ pGrid->addWidget(new QLabel(tr("Output frames"), this), nRow, 0);
+ pGrid->addWidget(m_pOutputFrameCountLabel, nRow++, 1, 1, 2);
+
+ m_pEstimatedDurationLabel = new QLabel(this);
+ pGrid->addWidget(new QLabel(tr("Estimated duration"), this), nRow, 0);
+ pGrid->addWidget(m_pEstimatedDurationLabel, nRow++, 1, 1, 2);
+ pGrid->setColumnStretch(1, 1);
+ pMainLayout->addLayout(pGrid);
+
+ m_pErrorLabel = new QLabel(this);
+ m_pErrorLabel->setStyleSheet("QLabel { color: #a32626; }");
+ m_pErrorLabel->setWordWrap(true);
+ pMainLayout->addWidget(m_pErrorLabel);
+
+ QDialogButtonBox* pButtonBox = new QDialogButtonBox(
+ QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
+ Qt::Horizontal, this);
+ QPushButton* pOkButton = pButtonBox->button(QDialogButtonBox::Ok);
+ QPushButton* pCancelButton = pButtonBox->button(QDialogButtonBox::Cancel);
+ pOkButton->setIcon(QIcon(exportDialogIconPath("OK.png")));
+ pCancelButton->setIcon(QIcon(exportDialogIconPath("Cancel.png")));
+ pOkButton->setIconSize(QSize(16, 16));
+ pCancelButton->setIconSize(QSize(16, 16));
+ pOkButton->setMinimumWidth(72);
+ pCancelButton->setMinimumWidth(72);
+ pMainLayout->addWidget(pButtonBox);
+
+ connect(m_pStartFrameCombo, SIGNAL(currentIndexChanged(int)),
+ this, SLOT(onFrameRangeChanged()));
+ connect(m_pEndFrameCombo, SIGNAL(currentIndexChanged(int)),
+ this, SLOT(onFrameRangeChanged()));
+ connect(m_pSamplingIntervalSpinBox, SIGNAL(valueChanged(int)),
+ this, SLOT(updateSummary()));
+ connect(m_pFpsSpinBox, SIGNAL(valueChanged(int)),
+ this, SLOT(updateSummary()));
+ connect(m_pResolutionCombo, SIGNAL(currentIndexChanged(int)),
+ this, SLOT(onResolutionPresetChanged(int)));
+ connect(m_pWidthSpinBox, SIGNAL(valueChanged(int)),
+ this, SLOT(updateSummary()));
+ connect(m_pHeightSpinBox, SIGNAL(valueChanged(int)),
+ this, SLOT(updateSummary()));
+ connect(m_pWidthSpinBox, SIGNAL(editingFinished()),
+ this, SLOT(normalizeCustomDimensions()));
+ connect(m_pHeightSpinBox, SIGNAL(editingFinished()),
+ this, SLOT(normalizeCustomDimensions()));
+ connect(pButtonBox, SIGNAL(accepted()),
+ this, SLOT(acceptSettings()));
+ connect(pButtonBox, SIGNAL(rejected()),
+ this, SLOT(reject()));
+}
+
+void nmWxPebiResultAnimationExportDlg::populateFrameItems()
+{
+ for(int nFrameIndex = 0;
+ nFrameIndex < m_vecFrameTimesHours.size(); ++nFrameIndex) {
+ const QString sText = tr("%1 h").arg(QString::number(
+ m_vecFrameTimesHours[nFrameIndex], 'g', 8));
+ m_pStartFrameCombo->addItem(sText, nFrameIndex);
+ m_pEndFrameCombo->addItem(sText, nFrameIndex);
+ }
+ if(!m_vecFrameTimesHours.isEmpty()) {
+ m_pStartFrameCombo->setCurrentIndex(0);
+ m_pEndFrameCombo->setCurrentIndex(
+ m_vecFrameTimesHours.size() - 1);
+ }
+}
+
+nmPebiResultAnimationExportSettings
+nmWxPebiResultAnimationExportDlg::collectSettings() const
+{
+ nmPebiResultAnimationExportSettings oSettings;
+ oSettings.m_nFramesPerSecond = m_pFpsSpinBox->value();
+ oSettings.m_nStartFrameIndex =
+ m_pStartFrameCombo->itemData(
+ m_pStartFrameCombo->currentIndex()).toInt();
+ oSettings.m_nEndFrameIndex =
+ m_pEndFrameCombo->itemData(
+ m_pEndFrameCombo->currentIndex()).toInt();
+ oSettings.m_nSamplingInterval =
+ m_pSamplingIntervalSpinBox->value();
+ oSettings.m_nOutputWidth =
+ normalizeEvenDimension(m_pWidthSpinBox->value());
+ oSettings.m_nOutputHeight =
+ normalizeEvenDimension(m_pHeightSpinBox->value());
+ return oSettings;
+}
+
+int nmWxPebiResultAnimationExportDlg::normalizeEvenDimension(int nValue)
+{
+ nValue = qBound(2, nValue, 8192);
+ if((nValue % 2) != 0) {
+ ++nValue;
+ }
+ return qMin(nValue, 8192);
+}
diff --git a/Src/nmNum/nmSubWxs/nmWxPebiResultControlBar.cpp b/Src/nmNum/nmSubWxs/nmWxPebiResultControlBar.cpp
index 1602b349..a9bd3d39 100644
--- a/Src/nmNum/nmSubWxs/nmWxPebiResultControlBar.cpp
+++ b/Src/nmNum/nmSubWxs/nmWxPebiResultControlBar.cpp
@@ -1,13 +1,16 @@
#include "nmWxPebiResultControlBar.h"
+#include "nmFFmpegVideoWriter.h"
#include "nmPebiResultPlaybackController.h"
#include "nmPebiResultPropertyDisplayText.h"
#include "nmPebiResultSceneController.h"
#include "nmWxPebiResultAnimationSettingsDlg.h"
#include "nmWxPebiResultColorScaleSettingsDlg.h"
+#include
#include
#include
+#include
#include
#include
#include
@@ -63,6 +66,9 @@ nmWxPebiResultControlBar::nmWxPebiResultControlBar(
m_pLastButton(nullptr),
m_pPlayPauseButton(nullptr),
m_pSettingsButton(nullptr),
+ m_pExportAction(nullptr),
+ m_pExportButton(nullptr),
+ m_bExportInProgress(false),
m_nDisplayedBindingRevision(0),
m_nDisplayedTimeFrameCount(-1)
{
@@ -106,9 +112,23 @@ nmWxPebiResultControlBar::getPlaybackController() const
return m_pPlaybackController;
}
+QAction* nmWxPebiResultControlBar::getExportAnimationAction() const
+{
+ return m_pExportAction;
+}
+
+void nmWxPebiResultControlBar::setExportInProgress(bool bInProgress)
+{
+ if(m_bExportInProgress == bInProgress) {
+ return;
+ }
+ m_bExportInProgress = bInProgress;
+ refreshFromController();
+}
+
void nmWxPebiResultControlBar::onPropertyIndexChanged(int nIndex)
{
- if(m_pPlaybackController == nullptr ||
+ if(m_pPlaybackController == nullptr || m_bExportInProgress ||
m_pPlaybackController->isPlaying() || nIndex < 0) {
return;
}
@@ -120,7 +140,7 @@ void nmWxPebiResultControlBar::onPropertyIndexChanged(int nIndex)
void nmWxPebiResultControlBar::onTimeIndexChanged(int nIndex)
{
- if(m_pPlaybackController == nullptr ||
+ if(m_pPlaybackController == nullptr || m_bExportInProgress ||
m_pPlaybackController->isPlaying() || nIndex < 0) {
return;
}
@@ -133,6 +153,7 @@ void nmWxPebiResultControlBar::onTimeIndexChanged(int nIndex)
void nmWxPebiResultControlBar::onColorSettingsClicked()
{
if(m_pPlaybackController == nullptr || m_pSceneController == nullptr ||
+ m_bExportInProgress ||
m_pPlaybackController->isPlaying() ||
!m_pSceneController->hasSnapshot()) {
return;
@@ -149,7 +170,7 @@ void nmWxPebiResultControlBar::onColorSettingsClicked()
void nmWxPebiResultControlBar::onFirstFrameClicked()
{
- if(m_pPlaybackController == nullptr ||
+ if(m_pPlaybackController == nullptr || m_bExportInProgress ||
m_pPlaybackController->isPlaying()) {
return;
}
@@ -160,7 +181,7 @@ void nmWxPebiResultControlBar::onFirstFrameClicked()
void nmWxPebiResultControlBar::onPreviousFrameClicked()
{
- if(m_pPlaybackController == nullptr ||
+ if(m_pPlaybackController == nullptr || m_bExportInProgress ||
m_pPlaybackController->isPlaying()) {
return;
}
@@ -171,7 +192,7 @@ void nmWxPebiResultControlBar::onPreviousFrameClicked()
void nmWxPebiResultControlBar::onNextFrameClicked()
{
- if(m_pPlaybackController == nullptr ||
+ if(m_pPlaybackController == nullptr || m_bExportInProgress ||
m_pPlaybackController->isPlaying()) {
return;
}
@@ -182,7 +203,7 @@ void nmWxPebiResultControlBar::onNextFrameClicked()
void nmWxPebiResultControlBar::onLastFrameClicked()
{
- if(m_pPlaybackController == nullptr ||
+ if(m_pPlaybackController == nullptr || m_bExportInProgress ||
m_pPlaybackController->isPlaying()) {
return;
}
@@ -193,7 +214,7 @@ void nmWxPebiResultControlBar::onLastFrameClicked()
void nmWxPebiResultControlBar::onPlayPauseClicked()
{
- if(m_pPlaybackController == nullptr) {
+ if(m_pPlaybackController == nullptr || m_bExportInProgress) {
return;
}
if(m_pPlaybackController->togglePlayback()) {
@@ -203,7 +224,7 @@ void nmWxPebiResultControlBar::onPlayPauseClicked()
void nmWxPebiResultControlBar::onAnimationSettingsClicked()
{
- if(m_pPlaybackController == nullptr ||
+ if(m_pPlaybackController == nullptr || m_bExportInProgress ||
m_pPlaybackController->isPlaying()) {
return;
}
@@ -219,6 +240,17 @@ void nmWxPebiResultControlBar::onAnimationSettingsClicked()
}
}
+void nmWxPebiResultControlBar::onExportAnimationTriggered()
+{
+ if(m_pPlaybackController == nullptr || m_bExportInProgress ||
+ m_pPlaybackController->isPlaying() ||
+ !m_pPlaybackController->isCurrentPropertyTimeDependent() ||
+ m_pPlaybackController->getCurrentPropertyFrameCount() <= 1) {
+ return;
+ }
+ emit exportAnimationRequested();
+}
+
void nmWxPebiResultControlBar::refreshFromController()
{
// 控件状态严格镜像四类 Scene 状态:无快照、静态、单帧动态、多帧动态。
@@ -240,6 +272,7 @@ void nmWxPebiResultControlBar::refreshFromController()
m_pLastButton->setEnabled(false);
m_pPlayPauseButton->setEnabled(false);
m_pSettingsButton->setEnabled(false);
+ m_pExportAction->setEnabled(false);
m_pPlayPauseButton->setIcon(QIcon(resultControlIconPath(
QString::fromLatin1("NmStartAnimation.png"))));
m_pPlayPauseButton->setToolTip(tr("Play"));
@@ -303,21 +336,33 @@ void nmWxPebiResultControlBar::refreshFromController()
const bool bHasMultipleFrames = bHasCompleteTimeList &&
nFrameCount > 1;
const bool bPlaying = m_pPlaybackController->isPlaying();
- m_pPropertyCombo->setEnabled(!bPlaying);
- m_pColorSettingsButton->setEnabled(!bPlaying);
- m_pTimeCombo->setEnabled(bHasTime && !bPlaying);
+ const bool bLocked = bPlaying || m_bExportInProgress;
+ m_pPropertyCombo->setEnabled(!bLocked);
+ m_pColorSettingsButton->setEnabled(!bLocked);
+ m_pTimeCombo->setEnabled(bHasTime && !bLocked);
m_pFirstButton->setEnabled(
- bHasMultipleFrames && nCurrentFrame > 0 && !bPlaying);
+ bHasMultipleFrames && nCurrentFrame > 0 && !bLocked);
m_pPreviousButton->setEnabled(
- bHasMultipleFrames && nCurrentFrame > 0 && !bPlaying);
+ bHasMultipleFrames && nCurrentFrame > 0 && !bLocked);
m_pNextButton->setEnabled(
bHasMultipleFrames &&
- nCurrentFrame < nFrameCount - 1 && !bPlaying);
+ nCurrentFrame < nFrameCount - 1 && !bLocked);
m_pLastButton->setEnabled(
bHasMultipleFrames &&
- nCurrentFrame < nFrameCount - 1 && !bPlaying);
- m_pPlayPauseButton->setEnabled(bHasMultipleFrames);
- m_pSettingsButton->setEnabled(bHasMultipleFrames && !bPlaying);
+ nCurrentFrame < nFrameCount - 1 && !bLocked);
+ m_pPlayPauseButton->setEnabled(
+ bHasMultipleFrames && !m_bExportInProgress);
+ m_pSettingsButton->setEnabled(bHasMultipleFrames && !bLocked);
+
+ QString sBackendError;
+ const bool bBackendAvailable =
+ nmFFmpegVideoWriter::isBackendAvailable(&sBackendError);
+ m_pExportAction->setEnabled(
+ bHasMultipleFrames && !bLocked && bBackendAvailable);
+ const QString sExportTip = bBackendAvailable
+ ? tr("Export animation") : sBackendError;
+ m_pExportAction->setToolTip(sExportTip);
+ m_pExportAction->setStatusTip(sExportTip);
m_pPlayPauseButton->setIcon(QIcon(resultControlIconPath(
bPlaying ? QString::fromLatin1("NmStopAnimation.png")
@@ -382,6 +427,19 @@ void nmWxPebiResultControlBar::createUi()
m_pSettingsButton = createControlButton(
this, QString::fromLatin1("NmAnimationSettings.png"),
tr("Animation settings"));
+ m_pExportAction = new QAction(
+ QIcon(resultControlIconPath("Export.png")),
+ tr("Export animation"), this);
+ m_pExportAction->setToolTip(tr("Export animation"));
+ m_pExportButton = new QToolButton(this);
+ m_pExportButton->setAutoRaise(true);
+ m_pExportButton->setFixedSize(24, 24);
+ m_pExportButton->setIconSize(QSize(16, 16));
+ m_pExportButton->setDefaultAction(m_pExportAction);
+
+ QFrame* pExportSeparator = new QFrame(this);
+ pExportSeparator->setFrameShape(QFrame::VLine);
+ pExportSeparator->setFrameShadow(QFrame::Sunken);
pLayout->addWidget(pPropertyLabel, 0, Qt::AlignVCenter);
pLayout->addWidget(m_pPropertyCombo);
@@ -393,8 +451,10 @@ void nmWxPebiResultControlBar::createUi()
pLayout->addWidget(m_pNextButton);
pLayout->addWidget(m_pLastButton);
pLayout->addWidget(m_pPlayPauseButton);
- pLayout->addWidget(m_pSettingsButton);
pLayout->addStretch(1);
+ pLayout->addWidget(m_pSettingsButton);
+ pLayout->addWidget(pExportSeparator);
+ pLayout->addWidget(m_pExportButton);
connect(m_pPropertyCombo, SIGNAL(currentIndexChanged(int)),
this, SLOT(onPropertyIndexChanged(int)));
@@ -414,6 +474,8 @@ void nmWxPebiResultControlBar::createUi()
this, SLOT(onPlayPauseClicked()));
connect(m_pSettingsButton, SIGNAL(clicked()),
this, SLOT(onAnimationSettingsClicked()));
+ connect(m_pExportAction, SIGNAL(triggered()),
+ this, SLOT(onExportAnimationTriggered()));
}
void nmWxPebiResultControlBar::rebuildPropertyItems(
diff --git a/Src/nmNum/nmSubWxs/nmWxPebiResultViewWidget.cpp b/Src/nmNum/nmSubWxs/nmWxPebiResultViewWidget.cpp
index 22f1b4f9..3ff7c2ff 100644
--- a/Src/nmNum/nmSubWxs/nmWxPebiResultViewWidget.cpp
+++ b/Src/nmNum/nmSubWxs/nmWxPebiResultViewWidget.cpp
@@ -1,26 +1,43 @@
#include "nmWxPebiResultViewWidget.h"
#include "nmDataAnalyzeManager.h"
+#include "nmFFmpegVideoWriter.h"
+#include "nmPebiResultAnimationExporter.h"
+#include "nmPebiResultDisplaySettings.h"
+#include "nmPebiResultPlaybackController.h"
#include "nmPebiResultSceneController.h"
#include "nmPebiResultSnapshot.h"
#include "nmVTKViewCommandController.h"
#include "nmWxPebiResultControlBar.h"
+#include "nmWxPebiResultAnimationExportDlg.h"
#include "nmWxVTKRenderContainerWidget.h"
#include
+#include
#include
+#include
+#include
+#include
#include
#include
#include
#include
+#include
+#include
+#include
#include
#include
#include
#include
#include
+#include
+#include
+
namespace {
+QAtomicInt g_nPebiAnimationExportActive(0);
+
QString resultViewIconPath(const QString& sFileName)
{
const QString sApplicationDir = QCoreApplication::applicationDirPath();
@@ -45,6 +62,94 @@ void setActionCheckedWithoutSignal(QAction* pAction, bool bChecked)
pAction->blockSignals(bBlocked);
}
+class AnimationExportGuard
+{
+public:
+ explicit AnimationExportGuard(nmWxPebiResultControlBar* pControlBar)
+ : m_pControlBar(pControlBar),
+ m_bAcquired(g_nPebiAnimationExportActive.testAndSetOrdered(0, 1))
+ {
+ if(m_bAcquired && m_pControlBar != nullptr) {
+ m_pControlBar->setExportInProgress(true);
+ }
+ }
+
+ ~AnimationExportGuard()
+ {
+ release();
+ }
+
+ void release()
+ {
+ if(!m_bAcquired) {
+ return;
+ }
+ if(m_pControlBar != nullptr) {
+ m_pControlBar->setExportInProgress(false);
+ }
+ g_nPebiAnimationExportActive.fetchAndStoreOrdered(0);
+ m_bAcquired = false;
+ }
+
+ bool isAcquired() const
+ {
+ return m_bAcquired;
+ }
+
+private:
+ QPointer m_pControlBar;
+ bool m_bAcquired;
+};
+
+QString videoSaveFilters()
+{
+ QStringList listFilters;
+ listFilters << QCoreApplication::translate(
+ "nmWxPebiResultViewWidget", "MP4 Video (*.mp4)")
+ << QCoreApplication::translate(
+ "nmWxPebiResultViewWidget", "AVI Video (*.avi)")
+ << QCoreApplication::translate(
+ "nmWxPebiResultViewWidget", "QuickTime Video (*.mov)")
+ << QCoreApplication::translate(
+ "nmWxPebiResultViewWidget", "MPEG Video (*.mpg)")
+ << QCoreApplication::translate(
+ "nmWxPebiResultViewWidget", "WebM Video (*.webm)")
+ << QCoreApplication::translate(
+ "nmWxPebiResultViewWidget", "Matroska Video (*.mkv)")
+ << QCoreApplication::translate(
+ "nmWxPebiResultViewWidget", "Windows Media Video (*.wmv)")
+ << QCoreApplication::translate(
+ "nmWxPebiResultViewWidget", "Flash Video (*.flv)");
+ return listFilters.join(QString::fromLatin1(";;"));
+}
+
+QString extensionFromFilter(const QString& sFilter)
+{
+ const QStringList listExtensions =
+ nmFFmpegVideoWriter::getSupportedExtensions();
+ for(int nIndex = 0; nIndex < listExtensions.size(); ++nIndex) {
+ const QString& sExtension = listExtensions[nIndex];
+ if(sFilter.contains(QString::fromLatin1("*.%1").arg(sExtension))) {
+ return sExtension;
+ }
+ }
+ return QString::fromLatin1("mp4");
+}
+
+QString normalizedVideoTargetPath(const QString& sPath,
+ const QString& sSelectedExtension)
+{
+ if(sPath.isEmpty()) {
+ return QString();
+ }
+ const QString sExistingExtension = QFileInfo(sPath).suffix().toLower();
+ if(sExistingExtension.isEmpty()) {
+ return sPath + QString::fromLatin1(".%1").arg(sSelectedExtension);
+ }
+ return nmFFmpegVideoWriter::isSupportedExtension(sExistingExtension)
+ ? sPath : QString();
+}
+
}
nmWxPebiResultViewWidget::nmWxPebiResultViewWidget(
@@ -173,6 +278,11 @@ void nmWxPebiResultViewWidget::appendContextMenuActions(QMenu* pMenu)
pMenu->addAction(m_pScalarBarAction);
pMenu->addAction(m_pScaleGridAction);
pMenu->addAction(m_pWellNamesAction);
+ if(m_pControlBar != nullptr &&
+ m_pControlBar->getExportAnimationAction() != nullptr) {
+ pMenu->addSeparator();
+ pMenu->addAction(m_pControlBar->getExportAnimationAction());
+ }
}
void nmWxPebiResultViewWidget::onControlOperationFailed(
@@ -207,6 +317,174 @@ void nmWxPebiResultViewWidget::onViewportSizeChanged(
}
}
+void nmWxPebiResultViewWidget::onExportAnimationRequested()
+{
+ nmPebiResultPlaybackController* pPlaybackController =
+ m_pControlBar == nullptr ? nullptr :
+ m_pControlBar->getPlaybackController();
+ QString sBackendError;
+ if(m_pSceneController == nullptr || m_pRenderContainer == nullptr ||
+ pPlaybackController == nullptr ||
+ pPlaybackController->isPlaying() ||
+ !m_pSceneController->hasSnapshot() ||
+ m_pDisplayedSnapshot.isNull() ||
+ !nmFFmpegVideoWriter::isBackendAvailable(&sBackendError)) {
+ if(!sBackendError.isEmpty()) {
+ QMessageBox::warning(this, tr("Export Animation"), sBackendError);
+ }
+ return;
+ }
+
+ AnimationExportGuard oExportGuard(m_pControlBar);
+ if(!oExportGuard.isAcquired()) {
+ QMessageBox::information(
+ this, tr("Export Animation"),
+ tr("Another result animation export is already in progress."));
+ return;
+ }
+
+ const QSharedPointer pFrozenSnapshot =
+ m_pDisplayedSnapshot;
+ const quint64 nFrozenBindingRevision =
+ m_pSceneController->getSnapshotBindingRevision();
+ const QString sFrozenSnapshotId =
+ m_pSceneController->getCurrentSnapshotId();
+ const QString sFrozenPropertyId =
+ m_pSceneController->getCurrentPropertyId();
+ const int nFrameCount = pFrozenSnapshot->getPropertyFrameCount(
+ sFrozenPropertyId);
+ if(nFrozenBindingRevision == 0 || sFrozenSnapshotId.isEmpty() ||
+ sFrozenPropertyId.isEmpty() || nFrameCount <= 1 ||
+ !m_pSceneController->isPropertyTimeDependent(sFrozenPropertyId)) {
+ return;
+ }
+
+ QVector vecFrameTimes;
+ vecFrameTimes.reserve(nFrameCount);
+ for(int nFrameIndex = 0; nFrameIndex < nFrameCount; ++nFrameIndex) {
+ double dTimeHours = 0.0;
+ if(!pFrozenSnapshot->getPropertyTimeAt(
+ sFrozenPropertyId, nFrameIndex, dTimeHours)) {
+ QMessageBox::warning(
+ this, tr("Export Animation"),
+ tr("Unable to read the result animation timeline."));
+ return;
+ }
+ vecFrameTimes.append(dTimeHours);
+ }
+
+ nmWxPebiResultAnimationExportDlg oSettingsDialog(
+ vecFrameTimes, m_pRenderContainer->getViewportSize(), this);
+ if(oSettingsDialog.exec() != QDialog::Accepted) {
+ return;
+ }
+
+ QString sSelectedFilter = videoSaveFilters().section(
+ QString::fromLatin1(";;"), 0, 0);
+ const QString sSelectedPath = QFileDialog::getSaveFileName(
+ this, tr("Save Result Animation"),
+ QDir::home().filePath(QString::fromLatin1("PEBI-result.mp4")),
+ videoSaveFilters(), &sSelectedFilter);
+ if(sSelectedPath.isEmpty()) {
+ return;
+ }
+ const QString sTargetPath = normalizedVideoTargetPath(
+ sSelectedPath, extensionFromFilter(sSelectedFilter));
+ if(sTargetPath.isEmpty()) {
+ QMessageBox::warning(
+ this, tr("Export Animation"),
+ tr("The selected video file extension is unsupported."));
+ return;
+ }
+ if(QFileInfo(sSelectedPath).suffix().isEmpty() &&
+ QFileInfo(sTargetPath).exists() &&
+ QMessageBox::question(
+ this, tr("Export Animation"),
+ tr("The selected file already exists. Replace it?"),
+ QMessageBox::Yes | QMessageBox::No,
+ QMessageBox::No) != QMessageBox::Yes) {
+ return;
+ }
+
+ // 参数和文件窗口都可能形成嵌套事件循环,开始前重新核对完整显示身份。
+ if(m_pDisplayedSnapshot.data() != pFrozenSnapshot.data() ||
+ m_pSceneController->getSnapshotBindingRevision() !=
+ nFrozenBindingRevision ||
+ m_pSceneController->getCurrentSnapshotId() != sFrozenSnapshotId ||
+ m_pSceneController->getCurrentPropertyId() != sFrozenPropertyId) {
+ QMessageBox::warning(
+ this, tr("Export Animation"),
+ tr("The displayed result changed before export started."));
+ return;
+ }
+
+ nmPebiResultDisplaySettings oDisplaySettings;
+ vtkRenderer* pRenderer = m_pRenderContainer->getRenderer();
+ if(!m_pSceneController->getCurrentDisplaySettings(oDisplaySettings) ||
+ pRenderer == nullptr || pRenderer->GetActiveCamera() == nullptr) {
+ QMessageBox::warning(
+ this, tr("Export Animation"),
+ tr("Unable to freeze the current result display."));
+ return;
+ }
+
+ nmPebiResultAnimationExporter::Request oRequest;
+ oRequest.m_pSnapshot = pFrozenSnapshot;
+ oRequest.m_sPropertyId = sFrozenPropertyId;
+ oRequest.m_oDisplaySettings = oDisplaySettings;
+ oRequest.m_oExportSettings = oSettingsDialog.getSettings();
+ oRequest.m_sTargetFilePath = QFileInfo(sTargetPath).absoluteFilePath();
+ oRequest.m_bScalarBarVisible =
+ m_pSceneController->isScalarBarVisible();
+ oRequest.m_bScaleGridVisible =
+ m_pSceneController->isScaleGridVisible();
+ oRequest.m_bWellNamesVisible =
+ m_pSceneController->areWellNamesVisible();
+ pRenderer->GetBackground(oRequest.m_dBackground);
+ pRenderer->GetBackground2(oRequest.m_dBackground2);
+ oRequest.m_bGradientBackground =
+ pRenderer->GetGradientBackground() != 0;
+ oRequest.m_pCamera = vtkSmartPointer::New();
+ oRequest.m_pCamera->DeepCopy(pRenderer->GetActiveCamera());
+
+ QProgressDialog oProgressDialog(
+ tr("Exporting result animation..."), tr("Cancel"),
+ 0, oRequest.m_oExportSettings.getOutputFrameCount(), this);
+ oProgressDialog.setWindowTitle(tr("Export Animation"));
+ oProgressDialog.setWindowModality(Qt::ApplicationModal);
+ oProgressDialog.setMinimumDuration(0);
+ oProgressDialog.setAutoClose(false);
+ oProgressDialog.setAutoReset(false);
+
+ nmPebiResultAnimationExporter oExporter;
+ connect(&oExporter, SIGNAL(progressChanged(int,int)),
+ &oProgressDialog, SLOT(setValue(int)));
+ connect(&oProgressDialog, SIGNAL(canceled()),
+ &oExporter, SLOT(cancel()));
+ oProgressDialog.show();
+
+ QString sExportError;
+ const nmPebiResultAnimationExporter::ExportResult eResult =
+ oExporter.exportAnimation(oRequest, &sExportError);
+ oProgressDialog.close();
+ oExportGuard.release();
+
+ if(eResult == nmPebiResultAnimationExporter::Export_Succeeded) {
+ onControlOperationSucceeded();
+ QMessageBox::information(
+ this, tr("Export Animation"),
+ tr("The result animation was saved to:\n%1")
+ .arg(QDir::toNativeSeparators(
+ oRequest.m_sTargetFilePath)));
+ } else if(eResult == nmPebiResultAnimationExporter::Export_Failed) {
+ QMessageBox::warning(
+ this, tr("Export Animation"),
+ sExportError.isEmpty()
+ ? tr("Unable to export the result animation.")
+ : sExportError);
+ }
+}
+
void nmWxPebiResultViewWidget::onScalarBarToggled(bool bVisible)
{
if(m_pSceneController != nullptr && m_pSceneController->hasSnapshot()) {
@@ -347,6 +625,8 @@ void nmWxPebiResultViewWidget::createUi()
this, SLOT(onControlOperationFailed(QString)));
connect(m_pControlBar, SIGNAL(operationSucceeded()),
this, SLOT(onControlOperationSucceeded()));
+ connect(m_pControlBar, SIGNAL(exportAnimationRequested()),
+ this, SLOT(onExportAnimationRequested()));
pMainLayout->addWidget(m_pControlBar);
synchronizeBusinessActions();
diff --git a/Src4/ffmpeg.pri b/Src4/ffmpeg.pri
new file mode 100644
index 00000000..6c9f6156
--- /dev/null
+++ b/Src4/ffmpeg.pri
@@ -0,0 +1,52 @@
+# PEBI动画导出使用的可选FFmpeg n1.1开发包。
+# nmSubWxs默认启用;其他目标可通过CONFIG显式选择是否接入。
+contains(CONFIG, nm_ffmpeg_video_export) {
+ FFMPEG_11_ROOT = $${geoHome}/3rd/FFmpeg-1.1
+ FFMPEG_11_VS2010_COMPAT = $${FFMPEG_11_ROOT}/compat/vs2010
+ FFMPEG_11_RUNTIME_DLLS = \
+ $${FFMPEG_11_ROOT}/bin/avformat-54.dll \
+ $${FFMPEG_11_ROOT}/bin/avcodec-54.dll \
+ $${FFMPEG_11_ROOT}/bin/avutil-52.dll \
+ $${FFMPEG_11_ROOT}/bin/swscale-2.dll
+
+ !exists($${FFMPEG_11_ROOT}/include/libavformat/avformat.h) {
+ error(FFmpeg n1.1 headers were not found in $${FFMPEG_11_ROOT}/include)
+ }
+ !exists($${FFMPEG_11_ROOT}/include/libavcodec/avcodec.h) {
+ error(FFmpeg n1.1 avcodec headers were not found)
+ }
+ !exists($${FFMPEG_11_ROOT}/include/libavutil/avutil.h) {
+ error(FFmpeg n1.1 avutil headers were not found)
+ }
+ !exists($${FFMPEG_11_ROOT}/include/libswscale/swscale.h) {
+ error(FFmpeg n1.1 swscale headers were not found)
+ }
+ !exists($${FFMPEG_11_ROOT}/lib/avformat.lib) {
+ error(FFmpeg n1.1 avformat import library was not found)
+ }
+ !exists($${FFMPEG_11_ROOT}/lib/avcodec.lib) {
+ error(FFmpeg n1.1 avcodec import library was not found)
+ }
+ !exists($${FFMPEG_11_ROOT}/lib/avutil.lib) {
+ error(FFmpeg n1.1 avutil import library was not found)
+ }
+ !exists($${FFMPEG_11_ROOT}/lib/swscale.lib) {
+ error(FFmpeg n1.1 swscale import library was not found)
+ }
+ !exists($${FFMPEG_11_VS2010_COMPAT}/inttypes.h) {
+ error(FFmpeg n1.1 VS2010 compatibility header inttypes.h was not found)
+ }
+
+ DEFINES += NM_ENABLE_FFMPEG_VIDEO_EXPORT
+ INCLUDEPATH += $${FFMPEG_11_VS2010_COMPAT}
+ INCLUDEPATH += $${FFMPEG_11_ROOT}/include
+ LIBS += -L$${FFMPEG_11_ROOT}/lib
+ LIBS += -lavformat -lavcodec -lavutil -lswscale
+
+ for(FFMPEG_11_RUNTIME_DLL, FFMPEG_11_RUNTIME_DLLS) {
+ !exists($${FFMPEG_11_RUNTIME_DLL}) {
+ error(FFmpeg runtime DLL was not found: $${FFMPEG_11_RUNTIME_DLL})
+ }
+ QMAKE_POST_LINK += $$QMAKE_COPY $$quote($${FFMPEG_11_RUNTIME_DLL}) $$quote($${DESTDIR}) $$escape_expand(\\n\\t)
+ }
+}
diff --git a/Src4/nmNum/nmSubWxs/nmSubWxs.pro b/Src4/nmNum/nmSubWxs/nmSubWxs.pro
index 26ba96bb..4f90e551 100644
--- a/Src4/nmNum/nmSubWxs/nmSubWxs.pro
+++ b/Src4/nmNum/nmSubWxs/nmSubWxs.pro
@@ -10,6 +10,8 @@ TEMPLATE = lib
include(../../setting.pri)
include(../../vtk.pri)
+CONFIG += nm_ffmpeg_video_export
+include(../../ffmpeg.pri)
DEFINES += NM_SUB_WXS_LIBRARY