添加项目文件。

.gitignore

@@ -0,0 +1,36 @@
+URMDemo/bin/
+URMPakcage/bin/
+URMDemo/obj/
+URMPakcage/obj/
+
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+ 
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+ 
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+ 
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+ 
+# Visual Studio 2015/2017 cache/options directory
+.vs/

URMDemo.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.8.34525.116
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "URMDemo", "URMDemo\URMDemo.csproj", "{4BBCC977-008C-4A81-A074-5C9C97650B8B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "URMPakcage", "URMPakcage\URMPakcage.csproj", "{9293B9C5-2079-4DEC-8DDF-1E4805ED2508}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{4BBCC977-008C-4A81-A074-5C9C97650B8B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4BBCC977-008C-4A81-A074-5C9C97650B8B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4BBCC977-008C-4A81-A074-5C9C97650B8B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4BBCC977-008C-4A81-A074-5C9C97650B8B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9293B9C5-2079-4DEC-8DDF-1E4805ED2508}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9293B9C5-2079-4DEC-8DDF-1E4805ED2508}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9293B9C5-2079-4DEC-8DDF-1E4805ED2508}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9293B9C5-2079-4DEC-8DDF-1E4805ED2508}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {C8FCCAEE-90FB-462A-9AA2-7C05DC23B480}
+	EndGlobalSection
+EndGlobal

URMDemo/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8" />
+    </startup>
+</configuration>

URMDemo/App.xaml

@@ -0,0 +1,9 @@
+<Application x:Class="URMDemo.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:URMDemo"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>

URMDemo/App.xaml.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using System.IO;
+
+using Vinno.Infrastructure;
+
+namespace URMDemo
+{
+    /// <summary>
+    /// App.xaml 的交互逻辑
+    /// </summary>
+    public partial class App : Application
+    {
+        protected override void OnStartup(StartupEventArgs e) {
+            AppendEnvironmentPath();
+        }
+
+        public void AppendEnvironmentPath()
+        {
+            var privatePath = @"C:\VinnoApp\Depends;C:\VinnoApp\ipp_2018;AIMeasure;AI;Depends;DicomMpeg;Syncfusion;RemoteDiagnosis;vCloud;Test;VFetus";
+            bool enforcePentiumMode = false;
+            string workPathPerCPU = string.Empty;
+            string workPathForGPU = string.Empty;
+            workPathPerCPU = Path.Combine(ServiceManager.RootPath, "NON_PENTIUM");
+
+            privatePath = privatePath + ";" + workPathPerCPU + ";";
+
+            string gpuName = string.Empty;
+
+            workPathForGPU = Path.Combine(ServiceManager.RootPath, "NVIDIA");
+
+            if (!string.IsNullOrEmpty(workPathForGPU))
+            {
+                privatePath = privatePath + workPathForGPU + ";";
+            }
+
+            if (!string.IsNullOrEmpty(privatePath))
+            {
+                string path = Environment.GetEnvironmentVariable("PATH");
+                string newPath = string.Empty;
+                if (path != null)
+                {
+                    string upperPath = path.ToUpper();
+                    var subPathes = privatePath.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
+                    foreach (var subPath in subPathes)
+                    {
+                        VinnoDirectoryInfo dir = null;
+                        if (Path.IsPathRooted(subPath))
+                        {
+                            dir = new VinnoDirectoryInfo(subPath);
+                        }
+                        else
+                        {
+                            dir = new VinnoDirectoryInfo(Path.Combine(ServiceManager.RootPath, subPath));
+                        }
+                        if (dir.Exists)
+                        {
+                            var fullName = dir.FullName;
+                            if (!upperPath.Contains(fullName.ToUpper()))
+                            {
+                                newPath += ";" + fullName;
+                            }
+                        }
+                    }
+
+                    if (!string.IsNullOrEmpty(newPath))
+                    {
+                        Environment.SetEnvironmentVariable("PATH", newPath + ";" + path, EnvironmentVariableTarget.Process);
+                    }
+                }
+            }
+        }
+    }
+}

URMDemo/MainWindow.xaml

@@ -0,0 +1,16 @@
+<Window x:Class="URMDemo.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:URMDemo"
+        mc:Ignorable="d"
+        Title="MainWindow" Height="450" Width="800">
+    <Grid>
+        <TextBlock x:Name="textBlock" HorizontalAlignment="Center" VerticalAlignment="Center"
+                   Text="Hello World" FontSize="24" Margin="0,0,0,50"/>
+        <Button x:Name="testButton" Content="Run URM" HorizontalAlignment="Center"
+                VerticalAlignment="Bottom" Margin="0,0,0,20" Width="100"
+                Visibility="Visible" Click="testButton_Click"/>
+    </Grid>
+</Window>

URMDemo/MainWindow.xaml.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Windows;
+using Vinno.Models.AdditionalFeatures.Functions.URM;
+
+namespace URMDemo
+{
+    /// <summary>
+    /// MainWindow.xaml 的交互逻辑
+    /// </summary>
+    public partial class MainWindow : Window
+    {
+
+        public MainWindow()
+        {
+            InitializeComponent();
+        }
+
+        private void testButton_Click(object sender, RoutedEventArgs e)
+        {
+            textBlock.Text = "URM Analysis Running...";
+            var _urmAnalysisProcess = new URMAnalysisProcess();
+            bool success = _urmAnalysisProcess.URMAnalysis("\"UrmDatapath\":\"D:\\TempURMFold\\2.dat\",\"VecLens\":\"474\",\"Mlas\":\"128\",\"VectorStartForMid\":\"9\",\"FramesGot\":\"1200\",\"CenterFrequencyMHz\":\"3.8\",\"Prf\":\"10313\",\"Angles\":\"29\",\"SupersonicSpeed\":\"1540\",\"PulseNum\":\"3\",\"FrequencyMin\":\"5\",\"FMUint\":\"MHz\",\"FrameRateDisplay\":\"101.9\",\"FDUnit\":\"Hz\",\"ScaleOfPixel_x\":\"0.212260852677748\",\"ScaleOfPixel_y\":\"0.493506493506494\",\"ULMCount\":\"400\",\"PacketsNum\":\"200\",\"Res\":\"2.5\",\"MaxLinkingDistance\":\"2\",\"MinLength\":\"5\",\"MaxGapClosing\":\"2\",\"LocMethod\":\"radial\",\"ButterCuttofFreqLow\":\"30\",\"NLocalMax\":\"3\",\"SVDCutoffLow\":\"30\",\"Fwhm\":\"3\",\"MOCOYN\":\"0\",\"MOCOLevel\":\"4\",\"MOCOThresh1\":\"0.05\",\"MOCOThresh2\":\"0.05\",\"MOCOThresh3\":\"5\",\"LocaFixmethod\":\"fixgray\",\"LocFixThresh\":\"25\",\"RefNum\":\"1\",\"MotionCorrThresh\":\"0.5\",\"Pos\":\" 14,33,94,327 \",\"FilterDeci\":\"1\",\"PSFNum\":\"10\",\"PSFCorr\":\"0.5\",\"Depth\":\"0\",\"X0\":\"0\",\"Z0\":\"0\",\"ProbeType\":\"1\",\"Decifactorx\":\"1\",\"Decifactory\":\"1\",\"SizeScan\":\"474\",\"MotionAngleThresh\":\"2\",\"TrackInterpFactor\":\"0.8\"");
+            Console.WriteLine($"_urmAnalysisProcess.URMAnalysis: {success}");
+            textBlock.Text = $"URM Analysis: {success}";
+            _urmAnalysisProcess.Release();
+        }
+    }
+}

URMDemo/Properties/AssemblyInfo.cs

@@ -0,0 +1,55 @@
+using System.Reflection;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Windows;
+
+// 有关程序集的一般信息由以下
+// 控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("URMDemo")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("URMDemo")]
+[assembly: AssemblyCopyright("Copyright ©  2024")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// 将 ComVisible 设置为 false 会使此程序集中的类型
+//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
+//请将此类型的 ComVisible 特性设置为 true。
+[assembly: ComVisible(false)]
+
+//若要开始生成可本地化的应用程序，请设置
+//.csproj 文件中的 <UICulture>CultureYouAreCodingWith</UICulture>
+//在 <PropertyGroup> 中。例如，如果你使用的是美国英语。
+//使用的是美国英语，请将 <UICulture> 设置为 en-US。  然后取消
+//对以下 NeutralResourceLanguage 特性的注释。  更新
+//以下行中的“en-US”以匹配项目文件中的 UICulture 设置。
+
+//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
+
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None, //主题特定资源词典所处位置
+                                     //(未在页面中找到资源时使用，
+                                     //或应用程序资源字典中找到时使用)
+    ResourceDictionaryLocation.SourceAssembly //常规资源词典所处位置
+                                              //(未在页面中找到资源时使用，
+                                              //、应用程序或任何主题专用资源字典中找到时使用)
+)]
+
+
+// 程序集的版本信息由下列四个值组成: 
+//
+//      主版本
+//      次版本
+//      生成号
+//      修订号
+//
+//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值
+//通过使用 "*"，如下所示:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

URMDemo/Properties/Resources.Designer.cs

@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本: 4.0.30319.42000
+//
+//     对此文件的更改可能导致不正确的行为，如果
+//     重新生成代码，则所做更改将丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace URMDemo.Properties
+{
+
+
+    /// <summary>
+    ///   强类型资源类，用于查找本地化字符串等。
+    /// </summary>
+    // 此类是由 StronglyTypedResourceBuilder
+    // 类通过类似于 ResGen 或 Visual Studio 的工具自动生成的。
+    // 若要添加或移除成员，请编辑 .ResX 文件，然后重新运行 ResGen
+    // (以 /str 作为命令选项)，或重新生成 VS 项目。
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources
+    {
+
+        private static global::System.Resources.ResourceManager resourceMan;
+
+        private static global::System.Globalization.CultureInfo resourceCulture;
+
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources()
+        {
+        }
+
+        /// <summary>
+        ///   返回此类使用的缓存 ResourceManager 实例。
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager
+        {
+            get
+            {
+                if ((resourceMan == null))
+                {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("URMDemo.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+
+        /// <summary>
+        ///   重写当前线程的 CurrentUICulture 属性，对
+        ///   使用此强类型资源类的所有资源查找执行重写。
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture
+        {
+            get
+            {
+                return resourceCulture;
+            }
+            set
+            {
+                resourceCulture = value;
+            }
+        }
+    }
+}

URMDemo/Properties/Resources.resx

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

URMDemo/Properties/Settings.Designer.cs

@@ -0,0 +1,30 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace URMDemo.Properties
+{
+
+
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
+    {
+
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+
+        public static Settings Default
+        {
+            get
+            {
+                return defaultInstance;
+            }
+        }
+    }
+}

URMDemo/Properties/Settings.settings

@@ -0,0 +1,7 @@
+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
+  <Profiles>
+    <Profile Name="(Default)" />
+  </Profiles>
+  <Settings />
+</SettingsFile>

URMDemo/URMDemo.csproj

@@ -0,0 +1,139 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{4BBCC977-008C-4A81-A074-5C9C97650B8B}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <RootNamespace>URMDemo</RootNamespace>
+    <AssemblyName>URMDemo</AssemblyName>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <WarningLevel>4</WarningLevel>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <Deterministic>true</Deterministic>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>x64</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>2</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject />
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xaml">
+      <RequiredTargetFramework>4.0</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="Vinno.Core, Version=1.11.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\URMPakcage\libs\Vinno.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="WindowsBase" />
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <Page Include="MainWindow.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Compile Include="App.xaml.cs">
+      <DependentUpon>App.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MainWindow.xaml.cs">
+      <DependentUpon>MainWindow.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Settings.settings</DependentUpon>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+    </Compile>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\URMPakcage\URMPakcage.csproj">
+      <Project>{9293b9c5-2079-4dec-8ddf-1e4805ed2508}</Project>
+      <Name>URMPakcage</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include=".NETFramework,Version=v4.8">
+      <Visible>False</Visible>
+      <ProductName>Microsoft .NET Framework 4.8 %28x86 和 x64%29</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

URMPakcage/Class1.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace URMPakcage
+{
+    public class Class1
+    {
+        
+    }
+}

URMPakcage/URM/SRColorBarAccessor.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Vinno.DataManager;
+using Vinno.Enums;
+using Vinno.Infrastructure;
+using Vinno.Infrastructure.DataTypes;
+using Vinno.Infrastructure.Media;
+using Vinno.Models.Base;
+using Vinno.Models.Base.Adorners;
+
+namespace URMPakcage.URM
+{
+    internal class SRColorBarAccessor
+    {
+    }
+
+    struct SRColorBarParam
+    {
+        public double Max { get; set; }
+        public double Min { get; set; }
+        public Unit Unit { get; set; }
+        public string ColorMap { get; set; }
+
+    }
+
+}

URMPakcage/URM/URMAnalysisProcess.cs

@@ -0,0 +1,702 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+using MathWorks.MATLAB.NET.Arrays;
+using SR_Main;
+using URMPakcage.URM;
+//using URMPakcage.utils;
+using Vinno.DataManager.Data;
+using Vinno.DataManager.GraphTransform;
+using Vinno.DataManager.Infrastructure;
+using Vinno.DataManager.Modes;
+using Vinno.DataManager.Process;
+using Vinno.DataManager.Utilities;
+using Vinno.DataTypes;
+using Vinno.Infrastructure;
+//using Vinno.Infrastructure;
+using Vinno.Models.Base.Modes;
+using Vinno.Models.Base.Parameters;
+using Vinno.Models.Base.ParamMetas;
+using Vinno.Models.Base.ViewPorts;
+//using System.Windows.Media.Imaging;
+
+
+using Vinno.Models.Base;
+using SkiaSharp;
+
+namespace Vinno.Models.AdditionalFeatures.Functions.URM
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public class URMAVIParam
+    {
+        public double Res { get; set; }
+        public double ScaleOfPixel_x { get; set; }
+        public double ScaleOfPixel_y { get; set; }
+        public double IntPowerDir { get; set; }
+        public double DownsampleIndexVideo { get; set; }
+        public IntPtr MaskArray { get; set; }
+        public URMAVIParam()
+        {
+            Res = 10;
+            ScaleOfPixel_x = 1.0;
+            ScaleOfPixel_y = 1.0;
+            IntPowerDir = 0.25;
+            DownsampleIndexVideo = 2;
+            MaskArray = IntPtr.Zero;
+        }
+    };
+
+    public struct POINT
+    {
+        public int X;
+        public int Y;
+
+        public POINT(int x, int y)
+        {
+            X = x;
+            Y = y;
+        }
+
+        public override string ToString()
+        {
+            return ("X:" + X + ", Y:" + Y);
+        }
+    }
+
+
+    public class URMAnalysisProcess
+    {
+
+        [DllImport("ImageProcessAlgWrapLib.dll")]
+        private static extern IntPtr PIA_CreateURMAnalysisDataProcess();
+        [DllImport("ImageProcessAlgWrapLib.dll")]
+        private static extern void PIA_URMAnalysisDataProcess_Release(IntPtr handPtr);
+        [DllImport("ImageProcessAlgWrapLib.dll")]
+        private static extern unsafe bool PIA_URMGetLastResultFromPackets(IntPtr handPtr, IntPtr srcMats, IntPtr srcMatdirs, IntPtr srcMatvels, int packets, int srcwidth, int srcheight, IntPtr dstMat, IntPtr dstMatdir, IntPtr dstMatvel);
+        [DllImport("ImageProcessAlgWrapLib.dll")]
+        private static extern void PIA_TransposeImg(IntPtr handPtr, IntPtr srcdst, int beams, int samples);
+        [DllImport("ImageProcessAlgWrapLibOld.dll")]
+        private static extern bool PIA_SRGetDensityImg(IntPtr handPtr, IntPtr srcMat, int srcWidth, int srcHeight,
+            IntPtr dstMat, IntPtr dstMatu, int dstWidth, int dstHeight, IntPtr colorMap, int colorMapLength, double lambda, ref double barmax, ref double barmin, double ScanScale);
+        [DllImport("ImageProcessAlgWrapLibOld.dll")]
+        private static extern void PIA_SetSrParam(IntPtr handPtr, SrParams srParams);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        private static extern bool GetCursorPos(out POINT pt);
+
+        private IntPtr _handle;
+        //private ModeRecord _urmModeRecord;
+        private bool initSrMain;
+        private int _urmwidth;
+        private int _urmheight;
+        private double lambda;
+        private int aviFrames;
+        private VinnoSR urmAnalysis;
+        //private IMode _mode;
+
+        private URMAVIParam _urmaviParam;
+
+        private double temp_ScaleOfPixel_x;
+        private double temp_ScaleOfPixel_y;
+
+        public double ScreenWidth = 980;
+        public double ScreenHeight = 650;
+
+
+        //public URMAnalysisProcess(IMode mode, ModeRecord modeRecord)
+        public URMAnalysisProcess()
+        {
+            POINT p = new POINT();
+            bool success = GetCursorPos(out p);
+            Console.WriteLine(p.ToString());
+            _handle = PIA_CreateURMAnalysisDataProcess();
+            urmAnalysis = new VinnoSR();
+            //_urmModeRecord = modeRecord;
+            //_mode = mode;
+            _urmaviParam = new URMAVIParam();
+        }
+
+        public void Release()
+        {
+            PIA_URMAnalysisDataProcess_Release(_handle);
+        }
+
+        private NativeArray srcArray;
+        private int SrcWidth;
+        private int SrcHeight;
+        private Dictionary<string, SRColorBarParam> srColorBarParams;
+        private NativeArray Densitycolormap;
+        private int Densitycolormaplength;
+
+
+        public bool URMAnalysis(string urmFold)
+        {
+
+            if (urmAnalysis == null)
+            {
+                Logger.WriteLineError("SuperResolution error: SrMain, _srMain is null");
+
+                return false;
+            }
+            LoadColorBarParams();
+
+            int urmStabilizer = 0;
+            MWArray folder = urmFold;
+            //if (ResourceManager.GetValue("Product-GeneralSpecification", "UrmParamLogOut", false))
+            //{
+            //    Logger.ForceWriteLine("Matlab " + folder);
+            //}
+            //urmStabilizer = (int)_mode.Parameters.GetItem<FloatParameter>(RecordParams.URMStabilizer).Value;
+            RecordNativeArray maskArray = new RecordNativeArray(0);
+            if (urmStabilizer < 2)
+            {
+                var MatOuts = new List<float[,]>();
+                var MatOutDirs = new List<float[,]>();
+                var MatOutVels = new List<float[,]>();
+                var PointList = new List<object[,]>();
+                initSrMain = false;
+                var results = (MWCellArray)urmAnalysis.SR_Main(folder);
+                object[,] resultArrays = (object[,])results.ToArray();
+                int packets = resultArrays.GetLength(1);
+                for (int i = 0; i < packets; i++)
+                {
+                    object[,,] curresult = (object[,,])resultArrays[0, i];
+                    float[,] curMat = (float[,])curresult[0, 0, 0];
+                    float[,] curMatdir = (float[,])curresult[1, 0, 0];
+                    float[,] curMatvel = (float[,])curresult[2, 0, 0];
+                    object[,] curPoints = (object[,])curresult[7, 0, 0];
+                    if (!initSrMain)
+                    {
+                        initSrMain = true;
+                        _urmwidth = curMat.GetLength(1);
+                        _urmheight = curMat.GetLength(0);
+                        float[,] lambdaArray = (float[,])curresult[6, 0, 0];
+                        lambda = (double)lambdaArray[0, 0];
+                        aviFrames = curPoints.GetLength(1);
+                        bool[,] maskdata = (bool[,])curresult[10, 0, 0];
+                        double[,] Scalers = (double[,])curresult[8, 0, 0];
+                        //var res = _urmModeRecord.GetParameter(RecordParams.URMRes, 10.0);
+                        var res = 2.5;
+                        var scaleofx = Scalers[0, 0] * res;
+                        var scaleofy = Scalers[0, 1] * res;
+                        temp_ScaleOfPixel_x = scaleofx;
+                        temp_ScaleOfPixel_y = scaleofy;
+                        //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_x, scaleofx);
+                        //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_y, scaleofy);
+                        unsafe
+                        {
+                            maskArray.Resize(_urmwidth * _urmheight * sizeof(byte));
+                            byte* maskArrayPtr = (byte*)maskArray.Start.ToPointer();
+                            for (int k = 0; k < _urmheight; k++)
+                            {
+                                for (int j = 0; j < _urmwidth; j++)
+                                {
+                                    var vel = maskdata[k, j];
+                                    maskArrayPtr[j + k * _urmwidth] = vel ? (byte)1 : (byte)0;
+                                }
+                            }
+                        }
+
+
+
+                    }
+                    MatOuts.Add(curMat);
+                    MatOutDirs.Add(curMatdir);
+                    MatOutVels.Add(curMatvel);
+                    PointList.Add(curPoints);
+
+                }
+                RecordNativeArray matout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
+                RecordNativeArray matdirout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
+                RecordNativeArray matvelout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
+                Console.WriteLine("Akio:_urmBeams is {0},_urmSamples is {1},packets is {2}", _urmwidth, _urmheight, packets);
+                long nativelength = (long)_urmwidth * (long)_urmheight * 4L * (long)packets;
+                NativeArray matOutNatveArray = new NativeArray(nativelength);
+                NativeArray matOutDirNatveArray = new NativeArray(nativelength);
+                NativeArray matOutVelNatveArray = new NativeArray(nativelength);
+                unsafe
+                {
+                    float* matOutNatveArrayPtr = (float*)matOutNatveArray.Start.ToPointer();
+                    float* matOutDirNatveArrayPtr = (float*)matOutDirNatveArray.Start.ToPointer();
+                    float* matOutVelNatveArrayPtr = (float*)matOutVelNatveArray.Start.ToPointer();
+                    for (int i = 0; i < packets; i++)
+                    {
+                        float* curmatOutNatveArrayPtr = matOutNatveArrayPtr + (long)i * (_urmwidth * _urmheight);
+                        float* curmatOutDirNatveArrayPtr = matOutDirNatveArrayPtr + (long)i * (_urmwidth * _urmheight);
+                        float* curmatOutVelNatveArrayPtr = matOutVelNatveArrayPtr + (long)i * (_urmwidth * _urmheight);
+                        float[,] MatOutArray = MatOuts[i];
+                        float[,] MatOutDirArray = MatOutDirs[i];
+                        float[,] MatOutVelArray = MatOutVels[i];
+                        unsafe
+                        {
+                            for (int k = 0; k < _urmheight; k++)
+                            {
+                                for (int j = 0; j < _urmwidth; j++)
+                                {
+                                    var vel = MatOutArray[k, j];
+                                    curmatOutNatveArrayPtr[j + k * _urmwidth] = vel;
+                                    var veldir = MatOutDirArray[k, j];
+                                    curmatOutDirNatveArrayPtr[j + k * _urmwidth] = veldir;
+                                    var velvel = MatOutVelArray[k, j];
+                                    curmatOutVelNatveArrayPtr[j + k * _urmwidth] = velvel;
+                                }
+                            }
+                        }
+                    }
+                    MatOuts.Clear();
+                    MatOutDirs.Clear();
+                    MatOutVels.Clear();
+
+
+
+                    PIA_URMGetLastResultFromPackets(_handle, matOutNatveArray.Start, matOutDirNatveArray.Start, matOutVelNatveArray.Start, packets, _urmwidth,
+                            _urmheight, matout.Start, matdirout.Start, matvelout.Start);
+
+                    matOutNatveArray.Dispose();
+                    matOutDirNatveArray.Dispose();
+                    matOutVelNatveArray.Dispose();
+
+                    SrcWidth = _urmwidth;
+                    SrcHeight = _urmheight;
+                    srcArray?.Dispose();
+                    srcArray = new NativeArray(SrcWidth * SrcHeight * 8);
+                    unsafe
+                    {
+                        double* img = (double*)srcArray.Start.ToPointer();
+                        double* matSrc = (double*)matout.Start.ToPointer();
+                        for (int i = 0; i < SrcWidth * SrcHeight; i++)
+                        {
+                            img[i] = matSrc[i];
+                            //Console.WriteLine(matSrc[i]);
+                        }
+                    }
+                    //_urmModeRecord.SetParameter(RecordParams.URMDenArray, matout, TimeStamp.ErrorTime);
+                    //_urmModeRecord.SetParameter(RecordParams.URMDirArray, matdirout, TimeStamp.ErrorTime);
+                    //_urmModeRecord.SetParameter(RecordParams.URMVelArray, matvelout, TimeStamp.ErrorTime);
+                    //_urmModeRecord.SetParameter(RecordParams.URMMask, maskArray, TimeStamp.ErrorTime);
+                    //_urmModeRecord.SetParameter(RecordParams.URMSrcHeight, _urmheight,TimeStamp.ErrorTime);
+                    //_urmModeRecord.SetParameter(RecordParams.URMSrcWidth, _urmwidth, TimeStamp.ErrorTime);
+                }
+
+
+
+
+                int[] PointNumList = new int[aviFrames];
+                List<URMPoint> pointsList = new List<URMPoint>();
+                for (int i = 0; i < aviFrames; i++)
+                {
+                    int PointNum = 0;
+                    for (int j = 0; j < PointList.Count; j++)
+                    {
+                        object[,] curpointArray = PointList[j];
+                        if (curpointArray[0, i] is double[,])
+                        {
+                            double[,] CurPointsArray = (double[,])curpointArray[0, i];
+                            var curPointsCount = CurPointsArray.GetLength(0);
+                            PointNum += curPointsCount;
+                            for (int k = 0; k < curPointsCount; k++)
+                            {
+                                URMPoint curPoint = new URMPoint();
+                                curPoint.X = (float)CurPointsArray[k, 0];
+                                curPoint.Y = (float)CurPointsArray[k, 1];
+                                curPoint.vel = (float)CurPointsArray[k, 2];
+                                pointsList.Add(curPoint);
+                            }
+                        }
+                        else if (curpointArray[0, i] is float[,])
+                        {
+                            float[,] CurPointsArray = (float[,])curpointArray[0, i];
+                            var curPointsCount = CurPointsArray.GetLength(0);
+                            PointNum += curPointsCount;
+                            for (int k = 0; k < curPointsCount; k++)
+                            {
+                                URMPoint curPoint = new URMPoint();
+                                curPoint.X = CurPointsArray[k, 0];
+                                curPoint.Y = CurPointsArray[k, 1];
+                                curPoint.vel = CurPointsArray[k, 2];
+                                pointsList.Add(curPoint);
+                            }
+                        }
+                    }
+                    PointNumList[i] = PointNum;
+                }
+                var pointsarray = pointsList.ToArray();
+                //_urmModeRecord.SetParameter(RecordParams.URMPoints, pointsarray, TimeStamp.ErrorTime);
+                //_urmModeRecord.SetParameter(RecordParams.URMPointNums, PointNumList, TimeStamp.ErrorTime);
+            }
+            else
+            {
+
+                var result = (MWStructArray)urmAnalysis.SR_Main(folder);
+                var MatOut = (MWNumericArray)result.GetField("MatOut");
+                var MatOut_zdir = (MWNumericArray)result.GetField("MatOut_zdir");
+                var MatOut_vel = (MWNumericArray)result.GetField("MatOut_vel");
+                var llz = (MWNumericArray)result.GetField("llz");
+                var llx = (MWNumericArray)result.GetField("llx");
+                var lambda = (MWNumericArray)result.GetField("lambda");
+                var Points = (MWCellArray)result.GetField("Points");
+                var Scalers = (MWNumericArray)result.GetField("SRscale");
+                double[,] scalersArray = (double[,])Scalers.ToArray();
+                //var res = _urmModeRecord.GetParameter(RecordParams.URMRes, 10.0);
+                //var scaleofx = scalersArray[0, 0] * res;
+                //var scaleofy = scalersArray[0, 1] * res;
+                //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_x, scaleofx);
+                //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_y, scaleofy);
+                var ROIMask = (MWLogicalArray)result.GetField("ROIMask");
+                double[,] lambdaArray = (double[,])lambda.ToArray();
+                //var lambda1 = lambdaArray[0, 0];
+                bool[,] maskdata = (bool[,])ROIMask.ToArray();
+                double[,] MatOutArray = (double[,])MatOut.ToArray();
+                double[,] MatOutDirArray = (double[,])MatOut_zdir.ToArray();
+                double[,] MatOutVelArray = (double[,])MatOut_vel.ToArray();
+                _urmwidth = MatOutArray.GetLength(1);
+                _urmheight = MatOutArray.GetLength(0);
+                RecordNativeArray matout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
+                RecordNativeArray matdirout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
+                RecordNativeArray matvelout = new RecordNativeArray(_urmwidth * _urmheight * sizeof(double));
+                maskArray.Resize(_urmwidth * _urmheight * sizeof(byte));
+                unsafe
+                {
+                    double* matOutNatveArrayPtr = (double*)matout.Start.ToPointer();
+                    double* matOutDirNatveArrayPtr = (double*)matdirout.Start.ToPointer();
+                    double* matOutVelNatveArrayPtr = (double*)matvelout.Start.ToPointer();
+                    byte* maskArrayPtr = (byte*)maskArray.Start.ToPointer();
+                    for (int i = 0; i < _urmheight; i++)
+                    {
+                        for (int j = 0; j < _urmwidth; j++)
+                        {
+                            var vel = MatOutArray[i, j];
+                            matOutNatveArrayPtr[j + i * _urmwidth] = vel;
+                            var veldir = MatOutDirArray[i, j];
+                            matOutDirNatveArrayPtr[j + i * _urmwidth] = veldir;
+                            var velvel = MatOutVelArray[i, j];
+                            matOutVelNatveArrayPtr[j + i * _urmwidth] = velvel;
+                            var maskvel = maskdata[i, j];
+                            maskArrayPtr[j + i * _urmwidth] = maskvel ? (byte)1 : (byte)0;
+                        }
+                    }
+                }
+                //_urmModeRecord.SetParameter(RecordParams.URMDenArray, matout, TimeStamp.ErrorTime);
+                //_urmModeRecord.SetParameter(RecordParams.URMDirArray, matdirout, TimeStamp.ErrorTime);
+                //_urmModeRecord.SetParameter(RecordParams.URMVelArray, matvelout, TimeStamp.ErrorTime);
+                //_urmModeRecord.SetParameter(RecordParams.URMSrcHeight, _urmheight, TimeStamp.ErrorTime);
+                //_urmModeRecord.SetParameter(RecordParams.URMSrcWidth, _urmwidth, TimeStamp.ErrorTime);
+                //_urmModeRecord.SetParameter(RecordParams.URMMask, maskArray, TimeStamp.ErrorTime);
+
+                object[,] pointArray = (object[,])Points.ToArray();
+                aviFrames = Points.Dimensions[1];
+                List<URMPoint> pointsList = new List<URMPoint>();
+                int[] PointNumList = new int[aviFrames];
+                for (int i = 0; i < aviFrames; i++)
+                {
+
+                    float[,] CurPointsArray = (float[,])pointArray[0, i];
+                    var curPointsCount = CurPointsArray.GetLength(0);
+                    for (int k = 0; k < curPointsCount; k++)
+                    {
+                        URMPoint curPoint = new URMPoint();
+                        curPoint.X = CurPointsArray[k, 0];
+                        curPoint.Y = CurPointsArray[k, 1];
+                        curPoint.vel = CurPointsArray[k, 2];
+                        pointsList.Add(curPoint);
+                    }
+                    PointNumList[i] = curPointsCount;
+                }
+                var pointsarray = pointsList.ToArray();
+                //_urmModeRecord.SetParameter(RecordParams.URMPoints, pointsarray, TimeStamp.ErrorTime);
+                //_urmModeRecord.SetParameter(RecordParams.URMPointNums, PointNumList, TimeStamp.ErrorTime);
+
+            }
+
+
+            /// 尝试获取图像并保存
+            var DensityColorParam = srColorBarParams["Density"];
+            var lambda1 = lambda;
+
+
+
+
+            int srcwidth = SrcWidth;
+            int srcheight = SrcHeight;
+
+            int dstwidthbeforeResize = (int)(srcwidth * 3 * (temp_ScaleOfPixel_y / temp_ScaleOfPixel_x) / 2.5 + 0.5);
+            int dstheightbeforeResiz = (int)(srcheight * temp_ScaleOfPixel_x / 2.5 + 0.5);
+            double widthScale = ScreenWidth / dstwidthbeforeResize;
+            double heightScale = ScreenHeight / dstheightbeforeResiz;
+            double ScanScale = widthScale < heightScale ? widthScale : heightScale;
+            //double ScanScale = 1.0;
+
+            //int dstwidth = (int)(dstwidthbeforeResize * ScanScale + 0.5);
+            //int dstheight = (int)(dstheightbeforeResiz * ScanScale + 0.5);
+
+            //int dstwidth = (int)(dstwidthbeforeResize);
+            //int dstheight = (int)(dstheightbeforeResiz);
+
+            int dstwidth = srcwidth;
+            int dstheight = srcheight;
+
+            //var cmPerPixel = GetCmPerPixel(srParams, ScanScale, lambda1);
+            //var scaleBar = _adorners.FirstOrDefault(x => x is TissueScaleBar) as TissueScaleBar;
+            //var logoMark = _adorners.FirstOrDefault(x => x is LogoMark) as LogoMark;
+            double tempmax = 2;
+            double tempmin = 1;
+            NativeArray dstArray = new NativeArray(4 * dstwidth * dstheight);
+            NativeArray dstArrayu = new NativeArray(8 * dstwidth * dstheight); //需要保存的原始八位数据
+            //NativeArray tempArray = new NativeArray(4 * dstwidth * dstheight);
+            GetSRColorMap(DensityColorParam.ColorMap, ref Densitycolormap, out Densitycolormaplength);
+
+            //unsafe
+            //{
+            //    double* img = (double*)srcArray.Start.ToPointer();
+            //    for (int i = 0; i < SrcWidth * SrcHeight; i++)
+            //    {
+            //        Console.WriteLine(img[i]);
+            //    }
+            //}
+            var srParams = new SrParams();
+            srParams.Res = 2.5;
+            srParams.ScaleOfPixel_x = temp_ScaleOfPixel_x;
+            srParams.ScaleOfPixel_y = temp_ScaleOfPixel_y;
+            srParams.DownsampleIndex = 1;
+            PIA_SetSrParam(_handle, srParams);
+
+            bool success = PIA_SRGetDensityImg(_handle, srcArray.Start, srcwidth, srcheight, dstArray.Start, dstArrayu.Start, dstwidth, dstheight, Densitycolormap.Start, Densitycolormaplength, lambda1, ref tempmax, ref tempmin, 1);
+            Console.WriteLine(success);
+            unsafe
+            {
+                byte* ptr = (byte*)dstArray.Start.ToPointer();
+
+                double* img = (double*)srcArray.Start.ToPointer();
+
+                for (int i = 0; i < dstwidth * dstheight; i++)
+                {
+                    Console.WriteLine(ptr[i * 4]);
+                    Console.WriteLine(ptr[i * 4 + 1]);
+                    Console.WriteLine(ptr[i * 4 + 2]);
+                    Console.WriteLine(ptr[i * 4 + 3]);
+                    if (img[i] > 0)
+                    {
+                        ptr[i * 4] = 0;
+                        ptr[i * 4 + 1] = 0;
+                        ptr[i * 4 + 2] = 180;
+                        ptr[i * 4 + 3] = 255;
+                    }
+
+
+                }
+            }
+
+            //var displayManager = new DisplayManager();
+            //displayManager.Setup(x => x.InitializeLanguage("CN"));
+            //serviceManagerImpl.RegisterService(typeof(IDisplayManager), displayManager.Object);
+            //var bitmap = CreateBitmapSource(dstwidth, dstheight, 96, 96, VPixelFormat.V_Bgr32,
+            //    tempArray.Start, (int)tempArray.Length, dstwidth * 4);
+            var converter = new ImageConverter();
+            if (converter.ConvertToImage(dstwidth, dstheight, dstArray.Start, (int)dstArray.Length, out SKBitmap bitmap))
+            {
+                // 使用bitmap，例如保存为文件
+                using (var image = SKImage.FromBitmap(bitmap))
+                using (var data = image.Encode(SKEncodedImageFormat.Png, 100))
+                {
+                    // 将数据编码为Base64字符串并打印
+                    var base64String = Convert.ToBase64String(data.ToArray());
+                    Console.WriteLine(base64String);
+                    // 获取当前时间戳
+                    string timeStamp = DateTime.Now.ToString("yyyyMMddHHmmss");
+
+                    // 获取图像分辨率
+                    string resolution = $"{dstwidth}x{dstheight}";
+
+                    // 创建带有时间戳和分辨率的文件名
+                    string fileName = $"output_{timeStamp}_{resolution}.png";
+                    using (var stream = System.IO.File.OpenWrite(fileName))
+                    {
+                        data.SaveTo(stream);
+                    }
+                }
+
+                // 释放资源
+                bitmap.Dispose();
+            }
+            dstArray.Dispose();
+            dstArrayu.Dispose();
+            return true;
+        }
+
+        //public IBitmapSource CreateBitmapSource(int pixelWidth, int pixelHeight, double dpiX, double dpiY,
+        //    VPixelFormat pixelFormat,  IntPtr buffer, int bufferSize, int stride)
+        //{
+        //    var wpfFormat = PixelFormatExtensions.ToWpfPixelFormat(pixelFormat);
+        //    var bitmap = BitmapSource.Create(pixelWidth, pixelHeight, dpiX, dpiY, wpfFormat, null, buffer, bufferSize, stride);
+        //    return new BitmapSourceContainer(bitmap);
+        //}
+
+        //public void SaveBitmapToFile(string filePath)
+        //{
+        //    var encoder = new PngBitmapEncoder();
+        //    encoder.Frames.Add(BitmapFrame.Create(_control));
+
+        //    using (var memoryStream = new MemoryStream())
+        //    {
+        //        encoder.Save(memoryStream);
+
+        //        using (var stream = new VinnoFileStream(filePath, FileMode.Create, FileAccess.ReadWrite,
+        //                FileShare.ReadWrite,
+        //                VinnoIO.BufferSize, FileOptions.WriteThrough))
+        //        {
+        //            memoryStream.WriteTo(stream);
+        //        }
+        //    }
+        //}
+
+        private void GetSRColorMap(string colorMap, ref NativeArray colorMapArray, out int talbelength)
+        {
+            colorMapArray?.Dispose();
+            var talbelengthlist = new List<int>();
+            var rValue = new List<int> { 0, 5, 8, 11, 13, 16, 19, 21, 24, 27, 29, 32, 35, 37, 40, 43, 45, 48, 50, 53, 56, 58, 61, 64, 66, 69, 72, 74, 77, 80, 82, 85, 88, 90, 93, 96, 98, 101, 104, 106, 109, 112, 114, 117, 120, 122, 125, 128, 130, 133, 135, 138, 141, 143, 146, 149, 151, 154, 157, 159, 162, 165, 167, 170, 173, 175, 178, 181, 183, 186, 189, 191, 194, 197, 199, 202, 205, 207, 210, 213, 215, 218, 220, 223, 226, 228, 231, 234, 236, 239, 242, 244, 247, 250, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 };
+            var gValue = new List<int> { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 8, 11, 13, 16, 19, 21, 24, 27, 29, 32, 35, 37, 40, 43, 45, 48, 50, 53, 56, 58, 61, 64, 66, 69, 72, 74, 77, 80, 82, 85, 88, 90, 93, 96, 98, 101, 104, 106, 109, 112, 114, 117, 120, 122, 125, 128, 130, 133, 135, 138, 141, 143, 146, 149, 151, 154, 157, 159, 162, 165, 167, 170, 173, 175, 178, 181, 183, 186, 189, 191, 194, 197, 199, 202, 205, 207, 210, 213, 215, 218, 220, 223, 226, 228, 231, 234, 236, 239, 242, 244, 247, 250, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 };
+            var bValue = new List<int> { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112, 116, 120, 124, 128, 131, 135, 139, 143, 147, 151, 155, 159, 163, 167, 171, 175, 179, 183, 187, 191, 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255 };
+            var result = true;
+            //var result = ((IDMVisual)_visual).Record.ImagePP.GetParameter(colorMap, "SR_Map_Length", talbelengthlist, null);
+            //talbelength = talbelengthlist[0];
+            talbelength = 256;
+            //result = ((IDMVisual)_visual).Record.ImagePP.GetParameter(colorMap, "SR_Map_R", rValue, null);
+            //result = result && ((IDMVisual)_visual).Record.ImagePP.GetParameter(colorMap, "SR_Map_G", gValue, null);
+            //result = result && ((IDMVisual)_visual).Record.ImagePP.GetParameter(colorMap, "SR_Map_B", bValue, null);
+            //ColorTable SRTable = new ColorTable(talbelength * sizeof(uint));
+
+            colorMapArray = new NativeArray(talbelength * 4);
+            if (result)
+            {
+                //IValueAccessor<uint> intValueAccessor = SRTable;
+                unsafe
+                {
+                    byte* colormapptr = (byte*)colorMapArray.Start.ToPointer();
+                    for (int i = 0; i < talbelength; i++)
+                    {
+                        colormapptr[4 * i] = (byte)bValue[i];
+                        colormapptr[4 * i + 1] = (byte)gValue[i];
+                        colormapptr[4 * i + 2] = (byte)rValue[i];
+                        colormapptr[4 * i + 3] = 0;
+                    }
+                }
+
+            }
+        }
+
+        private void LoadColorBarParams()
+        {
+            srColorBarParams = new Dictionary<string, SRColorBarParam>();
+            //var colorConfigs = ResourceManager.GetValue("SRMap", "SRMap", string.Empty);
+            var colorConfigs = "[\"Density SRColorMap:ColorMap1\" \"Direction SRColorMap:ColorMap2\" \"Vel SRColorMap:ColorMap3\" \"SRAvi SRColorMap:ColorMap4\"]";
+            if (!string.IsNullOrEmpty(colorConfigs))
+            {
+                EnumMeta enumMeta = ParamMetaSection.CreateMeta(colorConfigs) as EnumMeta;
+                if (enumMeta?.Values.Length > 0)
+                {
+                    foreach (var config in enumMeta.Values)
+                    {
+                        SRColorBarParam curBarParam = new SRColorBarParam();
+                        var elements = config.Split(' ');
+                        if (elements.Length == 2)
+                        {
+                            var title = elements[0].Trim();
+                            var mapConfigs = elements[1].Trim();
+                            curBarParam.ColorMap = mapConfigs;
+                            srColorBarParams.Add(title, curBarParam);
+                        }
+                    }
+                }
+            }
+        }
+
+
+        public void TransposeImg(IntPtr imgPtr, int beams, int samples)
+        {
+            PIA_TransposeImg(_handle, imgPtr, beams, samples);
+        }
+    }
+}
+
+public enum UrmImageType
+{
+    Unknown,
+    Raw,
+    Den,
+    Dir,
+    Vel
+}
+
+public class SrParams
+{
+    //Todo 拆分C++需要的参数
+    public double ScaleOfPixel_x { get; set; }
+    public double ScaleOfPixel_y { get; set; }
+    public double Res { get; set; }
+    public double DownsampleIndex { get; set; }
+    public double DownsampleIndexVideo { get; set; }
+    public double VideoNorIndex { get; set; }
+    public double IntPowerDen { get; set; }
+    public double IntPowerDir { get; set; }
+    public double SigmaGauss { get; set; }
+    public double VessScale { get; set; }
+    public double VelMaxValue { get; set; }
+    public double VelMinValue { get; set; }
+    public uint UrmLevel { get; set; }
+    public uint VideoParameter { get; set; }
+    public uint CaptureFrames { get; set; }
+    public float FrequencyMin { get; set; }
+    public string FrequencyMinUnit { get; set; }
+    public float FrameRateDisplay { get; set; }
+    public string FrameRateDisplayUnit { get; set; }
+
+    public uint VSpeckle { get; set; }
+    public uint Moco { get; set; }
+    public UrmImageType ImageType { get; set; }
+
+    public SrParams()
+    {
+        ScaleOfPixel_x = 1;
+        ScaleOfPixel_y = 1;
+        Res = 10;
+        DownsampleIndex = 3.0;
+        DownsampleIndexVideo = 1.5;
+        VideoNorIndex = 2;
+        IntPowerDen = 0.33;
+        IntPowerDir = 0.25;
+        SigmaGauss = 1.0;
+        VessScale = 0.2;
+        UrmLevel = 2;
+        VideoParameter = 2;
+        VelMaxValue = 1;
+        VelMinValue = 0;
+    }
+}
+
+public class ImageConverter
+{
+    public bool ConvertToImage(int dstWidth, int dstHeight, IntPtr tempArray, int tempArrayLength, out SKBitmap bitmap)
+    {
+        // 确保传入的参数有效
+        if (tempArray == IntPtr.Zero || tempArrayLength <= 0)
+        {
+            bitmap = null;
+            return false;
+        }
+
+        // 创建一个SKImageInfo对象来描述图像的信息
+        var info = new SKImageInfo(dstWidth, dstHeight, SKColorType.Bgra8888, SKAlphaType.Premul);
+
+        // 从内存数据创建SKBitmap
+        bitmap = new SKBitmap(info);
+
+        // 将内存数据拷贝到SKBitmap
+        bool success = bitmap.InstallPixels(info, tempArray, info.RowBytes, (addr, ctx) =>
+        {
+            /* 释放资源的回调函数 */
+        }, null);
+
+        return success;
+    }
+}

URMPakcage/URM/URMFileIO.cs

@@ -0,0 +1,208 @@
+//using Newtonsoft.Json;
+//using System;
+//using System.Collections.Generic;
+//using System.Diagnostics;
+//using System.IO;
+//using System.Text;
+//using System.Xml;
+//using Vinno.DataManager.Data;
+//using Vinno.DataManager.Infrastructure;
+//using Vinno.DataManager.Modes;
+//using Vinno.DataManager.Process;
+//using Vinno.Models.Base.Modes;
+//using Vinno.Models.Base.Parameters;
+//using Vinno.Modules.ClipboardModule.Models;
+
+//namespace Vinno.Models.AdditionalFeatures.Functions.URM
+//{
+    
+
+//    public class URMAnalysisParam
+//    {
+//        public  string UrmDatapath { get; set; }
+//        public string VecLens { get; set; }
+//        public string Mlas { get; set; }
+//        public string VectorStartForMid { get; set; }
+//        public string FramesGot { get; set; }
+//        public string CenterFrequencyMHz { get; set; }
+//        public string Prf { get; set; }
+//        public string Angles { get; set; }
+//        public string SupersonicSpeed { get; set; }
+//        public string PulseNum { get; set; }
+//        public string FrequencyMin { get; set; }
+//        public string FMUint { get; set; }
+//        public string FrameRateDisplay { get; set; }
+//        public string FDUnit { get; set; }
+//        public string ScaleOfPixel_x { get; set; }
+//        public string ScaleOfPixel_y { get; set; }
+//        public string ULMCount { get; set; }
+//        public string PacketsNum { get; set; }
+//        public string Res { get; set; }
+//        public string MaxLinkingDistance { get; set; }
+//        public string MinLength { get; set; }
+//        public string MaxGapClosing { get; set; }
+//        public string LocMethod { get; set; }
+//        public string ButterCuttofFreqLow { get; set; }
+//        public string NLocalMax { get; set; }
+//        public string SVDCutoffLow { get; set; }
+//        public string Fwhm { get; set; }
+//        public string MOCOYN { get; set; }
+//        public string MOCOLevel { get; set; }
+//        public string MOCOThresh1 { get; set; }
+//        public string MOCOThresh2 { get; set; }
+//        public string MOCOThresh3 { get; set; }
+//        public string LocaFixmethod { get; set; }
+//        public string LocFixThresh { get; set; }
+//        public string RefNum { get; set; }
+//        public string MotionCorrThresh { get; set; }
+//        public string Pos { get; set; }
+//        public string FilterDeci { get; set; }
+//        public string PSFNum { get; set; }
+//        public string PSFCorr { get; set; }
+
+//        public string Depth { get; set; }
+
+//        public string X0 { get; set; }
+
+//        public string Z0 { get; set; }
+
+//        public string ProbeType { get; set; }
+//        public string Decifactorx { get; set; }
+//        public string Decifactory { get; set; }
+
+//        public string SizeScan { get; set; }
+//        public string MotionAngleThresh { get; set; }
+//    }
+//    //负责URM的参数文件读写
+//    class URMFileIO
+//    {
+//        public const string ParamPosXml = "param_withpos.xml";
+//        protected ImagePP ImagePPRes;
+//        private IMode _urmMode;
+//        private string _urmpath;
+//        private readonly ModeRecord _oldModeRecord;
+//        private ModeRecord _urmModeRecord;
+//        private string _TempFold = @"D:\TempURMFold";
+//        public URMFileIO(IMode mode,ModeRecord urmModeRecord,ImagePP imagepp)
+//        {
+//            _urmMode = mode;
+//            ImagePPRes = imagepp;
+//            var dmmode = _urmMode as IDMMode;
+//            _oldModeRecord = dmmode?.ModeRecord;
+//            _oldModeRecord?.TryGetParameter<string>(RecordParams.URMDataFold, "", out _urmpath, TimeStamp.ErrorTime);
+//            _urmModeRecord = urmModeRecord;
+//        }
+
+//        public void UpdateParamPosJson(int startX, int startY, int width, int height, IClipImageSource clipImage, out string parmsWithPos)
+//        {
+//            var urmnalysisparams = new URMAnalysisParam();
+//            var srcpath = clipImage.GetImageFilePathPattern() + ".dat";
+//            var srcfold = Path.GetDirectoryName(srcpath);
+//            var datename = Path.GetFileName(srcpath);
+
+//            DirectoryInfo sourceInfo = new DirectoryInfo(_TempFold);
+//            if (sourceInfo.Exists)
+//                Directory.Delete(_TempFold);
+//            ProcessStartInfo startInfo = new ProcessStartInfo();
+//            startInfo.FileName = "cmd.exe";
+//            startInfo.Arguments = $"/C mklink /J \"{_TempFold}\" \"{srcfold}\"";
+//            startInfo.UseShellExecute = false;
+//            startInfo.RedirectStandardOutput = true;
+//            startInfo.CreateNoWindow = true;
+//            using (Process process = new Process())
+//            {
+//                process.StartInfo = startInfo;
+//                process.Start();
+//                // 等待命令执行完成
+//                process.WaitForExit();
+//            }
+//            //Datare_param
+//            urmnalysisparams.UrmDatapath =
+//                Path.Combine(_TempFold,datename);
+//            _oldModeRecord.TryGetParameter<int>(RecordParams.URMVecLens, out var veclens, TimeStamp.ErrorTime);
+//            urmnalysisparams.VecLens = veclens.ToString();
+//            _oldModeRecord.TryGetParameter<int>(RecordParams.URMMlas, out var Mlas, TimeStamp.ErrorTime);
+//            urmnalysisparams.Mlas = Mlas.ToString();
+//            _oldModeRecord.TryGetParameter<int>(RecordParams.URMVecStartForMid, out var VectorStartForMid, TimeStamp.ErrorTime);
+//            urmnalysisparams.VectorStartForMid = VectorStartForMid.ToString();
+//            _oldModeRecord.TryGetParameter<int>(RecordParams.URMFramesGet, out var Frames, TimeStamp.ErrorTime);
+//            urmnalysisparams.FramesGot = Frames.ToString();
+//            _oldModeRecord.TryGetParameter<double>(RecordParams.URMCenterFrequencyMHz, out var CenterFrequencyMhz, TimeStamp.ErrorTime);
+//            urmnalysisparams.CenterFrequencyMHz = CenterFrequencyMhz.ToString();
+//            _oldModeRecord.TryGetParameter<int>(RecordParams.URMPrf, out var Prf, TimeStamp.ErrorTime);
+//            urmnalysisparams.Prf = Prf.ToString();
+//            _oldModeRecord.TryGetParameter<int>(RecordParams.URMAngles, out var Angles, TimeStamp.ErrorTime);
+//            urmnalysisparams.Angles = Angles.ToString();
+//            _oldModeRecord.TryGetParameter<int>(RecordParams.URMSupersonicSpeed, out var SupersonicSpeed, TimeStamp.ErrorTime);
+//            urmnalysisparams.SupersonicSpeed = SupersonicSpeed.ToString();
+//            _oldModeRecord.TryGetParameter<int>(RecordParams.URMPulseNum, out var PulseNum, TimeStamp.ErrorTime);
+//            urmnalysisparams.PulseNum = PulseNum.ToString();
+//            _oldModeRecord.TryGetParameter<double>(RecordParams.URMFrequencyMin, out var FrequencyMin, TimeStamp.ErrorTime);
+//            urmnalysisparams.FrequencyMin = FrequencyMin.ToString();
+//            _oldModeRecord.TryGetParameter<string>(RecordParams.URMFrequencyMinUint, out var FrequencyMinUint, TimeStamp.ErrorTime);
+//            urmnalysisparams.FMUint = FrequencyMinUint;
+//            _oldModeRecord.TryGetParameter<double>(RecordParams.URMFrameRateDisplay, out var FrameRateDisplay, TimeStamp.ErrorTime);
+//            urmnalysisparams.FrameRateDisplay = FrameRateDisplay.ToString();
+//            _oldModeRecord.TryGetParameter<string>(RecordParams.URMFrameRateDisplayUnit, out var FrameRateDisplayUnit, TimeStamp.ErrorTime);
+//            urmnalysisparams.FDUnit = FrameRateDisplayUnit;
+//            _oldModeRecord.TryGetParameter<double>(RecordParams.URMDepth, out var URMDepth, TimeStamp.ErrorTime);
+//            urmnalysisparams.Depth = URMDepth.ToString();
+//            _oldModeRecord.TryGetParameter<double>(RecordParams.URMJSX, out var URMX0, TimeStamp.ErrorTime);
+//            urmnalysisparams.X0 = URMX0.ToString();
+//            _oldModeRecord.TryGetParameter<double>(RecordParams.URMJSZ, out var URMZ0, TimeStamp.ErrorTime);
+//            urmnalysisparams.Z0 = URMZ0.ToString();
+//            var linearScan = _oldModeRecord.GetDirectValue(RecordParams.SpcTr_isLinearGeom, false, false);
+//            if (linearScan)
+//                urmnalysisparams.ProbeType = "1";
+//            else
+//                urmnalysisparams.ProbeType = "2";
+//            //Vinnosr_param
+//            _oldModeRecord.TryGetParameter<double>(RecordParams.URMScaleOfPixel_x, out var ScaleOfPixel_x, TimeStamp.ErrorTime);
+//            urmnalysisparams.ScaleOfPixel_x = ScaleOfPixel_x.ToString();
+//            //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_x, ScaleOfPixel_x, TimeStamp.Zero);
+
+//            _oldModeRecord.TryGetParameter<double>(RecordParams.URMScaleOfPixel_y, out var ScaleOfPixel_y, TimeStamp.ErrorTime);
+//            urmnalysisparams.ScaleOfPixel_y = ScaleOfPixel_y.ToString();
+//            //_urmModeRecord.SetParameter(RecordParams.URMScaleOfPixel_y, ScaleOfPixel_y, TimeStamp.Zero);
+
+        
+//            var urmLevel = (int)_urmMode.Parameters.GetItem<FloatParameter>(RecordParams.URMLevel).Value;
+//            var section = "URMAnalysisParam:Level" + urmLevel;
+
+//            urmnalysisparams.ULMCount = ImagePPRes.GetValue(section, "ULMCount", 400).ToString();
+//            urmnalysisparams.PacketsNum = ImagePPRes.GetValue(section, "PacketsNum", 200).ToString();
+//            urmnalysisparams.Res = ImagePPRes.GetValue(section, "Res", 10.0d).ToString();
+//            _urmModeRecord.SetParameter(RecordParams.URMRes, urmnalysisparams.Res, TimeStamp.Zero);
+//            urmnalysisparams.MaxLinkingDistance = ImagePPRes.GetValue(section, "MaxLinkingDistance", 2.0).ToString();
+//            urmnalysisparams.MinLength = ImagePPRes.GetValue(section, "MinLength", 5.0).ToString();
+//            urmnalysisparams.MaxGapClosing = ImagePPRes.GetValue(section, "MaxGapClosing", 0).ToString();
+//            urmnalysisparams.LocMethod = ImagePPRes.GetValue(section, "LocMethod", "radial");
+//            urmnalysisparams.ButterCuttofFreqLow = ImagePPRes.GetValue(section, "ButterCuttofFreqLow", 30).ToString();
+//            urmnalysisparams.NLocalMax = ImagePPRes.GetValue(section, "NLocalMax", 3).ToString();
+//            urmnalysisparams.SVDCutoffLow = ImagePPRes.GetValue(section, "SVDCutoffLow", 30).ToString();
+//            urmnalysisparams.Fwhm = ImagePPRes.GetValue(section, "Fwhm", 3).ToString();
+
+//            var stabilizer = (int)_urmMode.Parameters.GetItem<FloatParameter>(RecordParams.URMStabilizer).Value;
+//            urmnalysisparams.MOCOYN = stabilizer.ToString();
+//            urmnalysisparams.MOCOLevel = ImagePPRes.GetValue(section, "MOCOLevel", 0.05).ToString();
+//            urmnalysisparams.MOCOThresh1 = ImagePPRes.GetValue(section, "MOCOThresh1", 0.05).ToString();
+//            urmnalysisparams.MOCOThresh2 = ImagePPRes.GetValue(section, "MOCOThresh2", 0.05).ToString();
+//            urmnalysisparams.MOCOThresh3 = ImagePPRes.GetValue(section, "MOCOThresh3", 5).ToString();
+//            urmnalysisparams.LocaFixmethod = ImagePPRes.GetValue(section, "LocaFixmethod", "fixgray");
+//            urmnalysisparams.LocFixThresh = ImagePPRes.GetValue(section, "LocFixThresh", 15).ToString();
+//            urmnalysisparams.RefNum = ImagePPRes.GetValue(section, "RefNum", 1).ToString();
+//            urmnalysisparams.MotionCorrThresh = ImagePPRes.GetValue(section, "MotionCorrThresh", 0.5).ToString();
+//            var roiInfo = $" {startX},{(startY + VectorStartForMid)},{width},{height} ";
+//            urmnalysisparams.Pos = roiInfo;
+//            urmnalysisparams.FilterDeci = ImagePPRes.GetValue(section, "FilterDeci", 1).ToString();
+//            urmnalysisparams.PSFNum = ImagePPRes.GetValue(section, "PSFNum", 10).ToString();
+//            urmnalysisparams.PSFCorr = ImagePPRes.GetValue(section, "PSFCorr", 0.5).ToString();
+//            urmnalysisparams.Decifactorx = ImagePPRes.GetValue(section, "Decifactorx", 1).ToString();
+//            urmnalysisparams.Decifactory = ImagePPRes.GetValue(section, "Decifactory", 1).ToString();
+//            urmnalysisparams.SizeScan = Math.Min(veclens, 1024).ToString();
+//            urmnalysisparams.MotionAngleThresh = ImagePPRes.GetValue(section, "MotionAngleThresh", 2).ToString();
+//            parmsWithPos = JsonConvert.SerializeObject(urmnalysisparams);
+//        }
+
+//    }
+//}

URMPakcage/URM/URMFunction.cs

@@ -0,0 +1,231 @@
+//using System;
+//using System.IO;
+//using System.Linq;
+//using Vinno.DataManager.Data;
+//using Vinno.DataManager.Infrastructure;
+//using Vinno.DataTypes;
+//using Vinno.Enums;
+//using Vinno.Models.Base;
+//using Vinno.Models.Base.Functions;
+//using Vinno.Models.Base.Modes;
+//using Vinno.Models.Base.Visuals;
+//using Vinno.Infrastructure;
+//using Vinno.Infrastructure.Interfaces;
+//using Vinno.Models.Base.Utilities;
+//using Vinno.Models.Zoom;
+//using Vinno.Services.MessageService;
+
+//namespace Vinno.Models.AdditionalFeatures.Functions.URM
+//{
+//    public partial class URMFunction : FunctionBase, IURMFunction, IPostInitialize
+//    {
+//        public const string Id = FunctionIds.URMFuction;
+
+//        private readonly IReplayVisual _visual;
+//        private readonly CaptureDataManager _captureDataManager;
+//        private readonly AnalysisResultManager _analysisResultManager;
+//        private readonly ProcessingBreaker _analysisProcessingBreaker;
+//        private readonly TraceManager _traceManager;
+
+//        private IWizardManager _wizardManager;
+
+//        private UrmStatus _urmStatus;
+//        private URMType _urmImageType;
+
+//        public UrmStatus UrmStatus
+//        {
+//            get => _urmStatus;
+//            private set
+//            {
+//                if (_urmStatus != value)
+//                {
+//                    _urmStatus = value;
+//                    OnUrmStatusChanged();
+//                }
+//            }
+//        }
+
+//        public bool CanSync => _analysisResultManager.CanSync;
+//        public bool IsSync => _analysisResultManager.IsSync;
+//        public bool IsTraceActive => _traceManager.IsActive;
+//        public IMode UrmMode => _analysisResultManager.UrmMode;
+
+//        public URMType UrmImageType
+//        {
+//            get => _urmImageType;
+//            private set
+//            {
+//                if (_urmImageType != value)
+//                {
+//                    _urmImageType = value;
+//                    OnUrmImageTypeChanged();
+//                }
+//            }
+//        }
+
+//        public event EventHandler UrmStatusChanged;
+//        public event EventHandler IsSyncChanged;
+//        public event EventHandler UrmImageTypeChanged;
+//        public event EventHandler IsTraceActiveChange;
+
+//        public URMFunction(IReplayVisual visual, SimultaneousTFViewer syncDisplay)
+//        {
+//            Name = Id;
+//            _visual = visual;
+//            _captureDataManager = new CaptureDataManager(this);
+//            _analysisResultManager = new AnalysisResultManager(this, syncDisplay);
+//            _analysisProcessingBreaker = new ProcessingBreaker();
+//            _traceManager = new TraceManager(this);
+
+//            _visual.ProbeChanged += OnProbeChanged;
+//            _visual.Manager.ScanImage.ActiveVisualChanged += ScanImageOnActiveVisualChanged;
+//        }
+
+//        public void PostInitialize()
+//        {
+//            _wizardManager = ServiceManager.Instance.GetService<IWizardManager>();
+//            var zoomFunction = _visual.SupportedFunctions.TryGetItem(ZoomFunction.Id) as ZoomFunction;
+
+//            _captureDataManager.Initialize(zoomFunction);
+//            _analysisResultManager.Initialize(_wizardManager, zoomFunction);
+//            _traceManager.Initialize(zoomFunction);
+//        }
+
+//        public bool HasCaptureData(IReplayVisual replayVisual, IDMMode dmMode)
+//        {
+//            if (!string.IsNullOrWhiteSpace(replayVisual.ImageFilePath))
+//            {
+//                //todo 临时写法，后面有时间需要和TissueViewModel.UrmPanel中一起调整URM数据文件路径的获取方式。
+//                var urmDataFile = replayVisual.ImageFilePath.Replace(".0", ".dat");
+//                if (VinnoFile.Exists(urmDataFile) &&
+//                    dmMode.ModeRecord.TryGetParameter<bool>(RecordParams.URMFlag, "", out var urmFlag, TimeStamp.LastTime) &&
+//                    urmFlag)
+//                {
+//                    return true;
+//                }
+//            }
+
+//            return false;
+//        }
+
+//        private void OnProbeChanged(object sender, EventArgs e)
+//        {
+//            Deactivate();
+//            Activate();
+//            if (_analysisProcessingBreaker.Paused)
+//            {
+//                _analysisResultManager.OpenSyncDisplay(true);
+//            }
+//        }
+
+//        private void ScanImageOnActiveVisualChanged(object sender, EventArgs e)
+//        {
+//            if (_visual.Manager.ScanImage.ActiveVisual != _visual)
+//            {
+//                Deactivate();
+//            }
+//            else
+//            {
+//                Activate();
+//            }
+//        }
+
+//        private void Activate()
+//        {
+//            var mode = _visual.WorkingModes.FirstOrDefault(x => x is IURM);
+//            if (mode != null)
+//            {
+//                _analysisResultManager.Activate(mode);
+//                UrmStatus = UrmStatus.AnalysisResult;
+//                return;
+//            }
+
+//            mode = _visual.WorkingModes.FirstOrDefault(x => x is IUrmCBI || x is IUrmTwoDMode);
+//            if (mode != null &&
+//                HasCaptureData(_visual, (IDMMode)mode))
+//            {
+//                _captureDataManager.Activate();
+//                UrmStatus = UrmStatus.CaptureData;
+//            }
+//        }
+
+//        private void Deactivate()
+//        {
+//            if (UrmStatus == UrmStatus.CaptureData)
+//            {
+//                _captureDataManager.Deactivate();
+//                UrmStatus = UrmStatus.None;
+//            }
+//            else if (UrmStatus == UrmStatus.AnalysisResult)
+//            {
+//                if (_traceManager.IsActive)
+//                {
+//                    _traceManager.Deactivate();
+//                }
+//                _analysisResultManager.Deactivate();
+//                UrmStatus = UrmStatus.None;
+//            }
+//        }
+
+//        public void Analysis()
+//        {
+//            _captureDataManager.Analysis();
+//        }
+
+//        public void OpenSyncDisplay(bool isOpenSync)
+//        {
+//            _analysisResultManager.OpenSyncDisplay(isOpenSync);
+//        }
+
+//        public void SaveUrmVideo()
+//        {
+//            _analysisResultManager.SaveUrmVideo();
+//        }
+
+//        public void ActivateTrace()
+//        {
+//            if (UrmStatus == UrmStatus.AnalysisResult)
+//            {
+//                _traceManager.Activate();
+//            }
+//        }
+
+//        public void DeactivateTrace()
+//        {
+//            if (_traceManager.IsActive)
+//            {
+//                _traceManager.Deactivate();
+//            }
+//        }
+
+//        public void RestoreTrace()
+//        {
+//            if (_traceManager.IsActive)
+//            {
+//                _traceManager.Deactivate();
+//            }
+
+//            _analysisResultManager.CutImage(new DPoint[0]);
+//        }
+
+//        protected virtual void OnUrmStatusChanged()
+//        {
+//            UrmStatusChanged?.Invoke(this, EventArgs.Empty);
+//        }
+
+//        protected virtual void OnIsSyncChanged()
+//        {
+//            IsSyncChanged?.Invoke(this, EventArgs.Empty);
+//        }
+
+//        protected virtual void OnUrmImageTypeChanged()
+//        {
+//            UrmImageTypeChanged?.Invoke(this, EventArgs.Empty);
+//        }
+
+//        protected virtual void OnIsTraceActiveChange()
+//        {
+//            IsTraceActiveChange?.Invoke(this, EventArgs.Empty);
+//        }
+//    }
+//}

URMPakcage/URM/URMFunction_AnalysisResultManager.cs

@@ -0,0 +1,454 @@
+//using System;
+//using System.Collections.Generic;
+//using System.ComponentModel;
+//using System.Linq;
+//using UtilityService;
+//using Vinno.DataManager;
+//using Vinno.DataManager.Infrastructure;
+//using Vinno.DataManager.Infrastructure.Interfaces;
+//using Vinno.DataManager.Modes;
+//using Vinno.DataManager.Process.ProcessManagers;
+//using Vinno.DataManager.Records;
+//using Vinno.DataManager.Utilities;
+//using Vinno.DataTypes;
+//using Vinno.Enums;
+//using Vinno.Infrastructure;
+//using Vinno.Infrastructure.Enums;
+//using Vinno.Infrastructure.Media;
+//using Vinno.Models.Adorners.Urm;
+//using Vinno.Models.Base;
+//using Vinno.Models.Base.Functions;
+//using Vinno.Models.Base.ImageStorage;
+//using Vinno.Models.Base.Modes;
+//using Vinno.Models.Base.Parameters;
+//using Vinno.Models.Base.ParamMetas;
+//using Vinno.Models.Base.ViewPorts;
+//using Vinno.Models.Base.Visuals;
+//using Vinno.Models.SpecificImpl.Probes;
+//using Vinno.Models.Zoom;
+//using Vinno.Modules.ClipboardModule;
+//using Vinno.ProcessUnits.DisplayLib;
+//using Vinno.Services.MessageService;
+
+//namespace Vinno.Models.AdditionalFeatures.Functions.URM
+//{
+//    public partial class URMFunction
+//    {
+//        private class AnalysisResultManager
+//        {
+//            private readonly URMFunction _owner;
+//            private readonly IReplayVisual _visual;
+//            private readonly IViewPort _tissueAreaViewPort;
+//            private readonly SimultaneousTFViewer _syncDisplay;
+//            private ZoomFunction _zoomFunction;
+
+//            private readonly UrmColorMapManager _urmColorMapManager;
+//            private readonly UrmVideoSaver _urmVideoSaver;
+//            private readonly UrmScaleLine _urmScaleLine;
+
+//            private Record _record;
+//            private ModeRecord _urmModeRecord;
+//            private ModeRecord _tissueModeRecord;
+//            private StringParameter _imageTypeParameter;
+//            private StringParameter _colorTableNameParameter;
+//            private double _urmLinearTilt;
+
+//            private DPoint[] _tracePoints;
+//            private bool _isSyncOfTracePoints;
+
+//            public bool CanSync { get; private set; }
+//            public bool IsSync => _syncDisplay.Running;
+//            public IMode UrmMode { get; private set; }
+
+//            public AnalysisResultManager(URMFunction owner, SimultaneousTFViewer syncDisplay)
+//            {
+//                _owner = owner;
+//                _visual = owner._visual;
+//                _tissueAreaViewPort = _visual.PrimaryTissueArea.ViewPort;
+//                _syncDisplay = syncDisplay;
+
+//                _urmColorMapManager = new UrmColorMapManager();
+//                _urmVideoSaver = new UrmVideoSaver(_visual, _urmColorMapManager);
+//                _urmScaleLine = new UrmScaleLine() { IsVisible = true };
+
+//                _owner._urmImageType = URMType.UnKnown;
+//            }
+
+//            public void Initialize(IWizardManager wizardManager, ZoomFunction zoomFunction)
+//            {
+//                _urmVideoSaver.Initialize(wizardManager);
+//                _zoomFunction = zoomFunction;
+//            }
+
+//            public void Activate(IMode mode)
+//            {
+//                UrmMode = mode;
+//                _urmModeRecord = ((IDMMode)mode).ModeRecord;
+//                _record = _urmModeRecord.Record;
+//                _tissueModeRecord = _record.Modes.FirstOrDefault(x => x.Kind().IsTissue() && x.ModeName != N.URM);
+//                CanSync = _tissueModeRecord != null;
+
+//                _urmVideoSaver.Activate(_record, _urmModeRecord);
+
+//                ((IURM)UrmMode).UploadParameterDefaultValue();
+//                _urmLinearTilt = _urmModeRecord.GetParameter<double>(RecordParams.UrmLinearTilt);
+//                _tracePoints = _urmModeRecord.GetParameter<DPoint[]>(RecordParams.URMTracePoints) ?? new DPoint[0];
+//                _isSyncOfTracePoints = _record.GetParameter<bool>(ParamCategoryEnum.UIControls, RecordParams.SimultaneousTF);
+
+//                _imageTypeParameter = UrmMode.Parameters.GetItem<StringParameter>(RecordParams.UrmImageType);
+//                _colorTableNameParameter = UrmMode.Parameters.GetItem<StringParameter>(RecordParams.URMColorTableName);
+//                _imageTypeParameter.ValueChanged += ImageTypeParameterOnValueChanged;
+//                ImageTypeParameterOnValueChanged(this, EventArgs.Empty);
+
+//                _visual.PrimaryTissueArea.AddSychroAdorner(_urmScaleLine);
+//                _tissueAreaViewPort.Updated += ViewPortOnUpdated;
+//                ViewPortOnUpdated(this, EventArgs.Empty);
+
+//                _syncDisplay.Enabled = true;
+//                _syncDisplay.PreRunningChanged += OnPreRunningChanged;
+//                _syncDisplay.StateChanged += SyncDisplayOnStateChanged;
+//            }
+
+//            public void Deactivate()
+//            {
+//                CanSync = false;
+
+//                _urmVideoSaver.Deactivate();
+
+//                _imageTypeParameter.ValueChanged -= ImageTypeParameterOnValueChanged;
+//                _owner.UrmImageType = URMType.UnKnown;
+
+//                _visual.PrimaryTissueArea.RemoveSychroAdorner(_urmScaleLine);
+//                _tissueAreaViewPort.Updated -= ViewPortOnUpdated;
+
+//                _syncDisplay.Enabled = false;
+//                _syncDisplay.PreRunningChanged -= OnPreRunningChanged;
+//                _syncDisplay.StateChanged -= SyncDisplayOnStateChanged;
+//            }
+
+//            private void ImageTypeParameterOnValueChanged(object sender, EventArgs e)
+//            {
+//                if (Enum.TryParse(_imageTypeParameter.Value, out URMType type))
+//                {
+//                    _owner.UrmImageType = type;
+//                    switch (type)
+//                    {
+//                        case URMType.Den:
+//                            _colorTableNameParameter.Value = _urmColorMapManager.GetAvailableColorMap("Density");
+//                            break;
+//                        case URMType.Dir:
+//                            _colorTableNameParameter.Value = _urmColorMapManager.GetAvailableColorMap("Direction");
+//                            break;
+//                        case URMType.Vel:
+//                            _colorTableNameParameter.Value = _urmColorMapManager.GetAvailableColorMap("Vel");
+//                            break;
+//                    }
+//                }
+//            }
+
+//            private void ViewPortOnUpdated(object sender, EventArgs e)
+//            {
+//                UpdateScaleLineLength();
+//                ConvertAndUpload(_tracePoints);
+//            }
+
+//            private void UpdateScaleLineLength()
+//            {
+//                _urmScaleLine.UpdateLineLength(_tissueAreaViewPort.ImageBoundary);
+//            }
+
+//            private void OnPreRunningChanged(object sender, CancelEventArgs e)
+//            {
+//                if (_tissueModeRecord == null)
+//                {
+//                    e.Cancel = true;
+//                    return;
+//                }
+
+//                if (_zoomFunction?.Running == true)
+//                {
+//                    _zoomFunction.ZoomStatus = ZoomStatus.None;
+//                }
+
+//                var isOpenSync = IsSync;
+
+//                SetModeRecordTitle(isOpenSync, _urmLinearTilt);
+//                var tracePoints = GetTracePointsWithTilt(_tracePoints, _isSyncOfTracePoints, isOpenSync, _urmLinearTilt, out var isChanged);
+//                if (isChanged)
+//                {
+//                    SaveTracePoints(tracePoints, isOpenSync);
+//                }
+
+//                UpdateRecord(isOpenSync, _tissueModeRecord, _urmModeRecord);
+//                ReinitializeProcessUnit();
+//            }
+
+//            private void SyncDisplayOnStateChanged(object sender, EventArgs e)
+//            {
+//                _owner.OnIsSyncChanged();
+//                UrmMode.Parameters.GetItem<BoolParameter>(RecordParams.URMSyncDisplay).Value = _syncDisplay.Running;
+//            }
+
+//            public void OpenSyncDisplay(bool isOpenSync)
+//            {
+//                _syncDisplay.Running = isOpenSync;
+            
+//            }
+
+//            private void SetModeRecordTitle(bool isOpenSync, double tilt)
+//            {
+//                if (_visual.Probe is LinearProbe)
+//                {
+//                    var urmCache = _urmModeRecord.ProcessingOutput;
+//                    if (isOpenSync)
+//                    {
+//                        urmCache.SetParameter(RecordParams.SpcTr_HorOrigin, tilt);
+//                        urmCache.SetParameter(RecordParams.SSTilt, tilt);
+//                        _urmModeRecord.SetParameter(RecordParams.SpcTr_HorOrigin, tilt);
+//                        _urmModeRecord.SetParameter(RecordParams.SSTilt, tilt);
+//                    }
+//                    else
+//                    {
+//                        urmCache.SetParameter(RecordParams.SpcTr_HorOrigin, 0d);
+//                        urmCache.SetParameter(RecordParams.SSTilt, 0d);
+//                        _urmModeRecord.SetParameter(RecordParams.SpcTr_HorOrigin, 0d);
+//                        _urmModeRecord.SetParameter(RecordParams.SSTilt, 0d);
+//                    }
+//                }
+//            }
+
+//            private void UpdateRecord(bool isOpenSync, ModeRecord tissueModeRecord, ModeRecord urmModeRecord)
+//            {
+//                _record.RemoveModeRecord(_tissueModeRecord);
+//                _record.RemoveModeRecord(_urmModeRecord);
+
+//                if (isOpenSync)
+//                {
+//                    _record.AddModeRecord(_tissueModeRecord);
+//                    _record.AddModeRecord(_urmModeRecord);
+
+//                    if (_visual.Probe is LinearProbe linear)
+//                    {
+//                        linear.ProbeWidth = tissueModeRecord.GetParameter<double>(RecordParams.ProbeWidth);
+//                    }
+//                }
+//                else
+//                {
+//                    _record.AddModeRecord(_urmModeRecord);
+//                    _record.AddModeRecord(_tissueModeRecord);
+
+//                    if (_visual.Probe is LinearProbe linear)
+//                    {
+//                        linear.ProbeWidth = urmModeRecord.GetParameter<double>(RecordParams.ProbeWidth);
+//                    }
+//                }
+//            }
+
+//            private void ReinitializeProcessUnit()
+//            {
+//                ((IDMVisual)_visual).SetDMParameter(_urmModeRecord, RecordParams.ReinitializeProcessUnit, true);
+//            }
+
+//            public void CutImage(DPoint[] tracePoints)
+//            {
+//                SaveTracePoints(tracePoints, IsSync);
+//                ConvertAndUpload(tracePoints);
+//            }
+
+//            private void SaveTracePoints(DPoint[] tracePoints, bool isSync)
+//            {
+//                _tracePoints = tracePoints;
+//                _isSyncOfTracePoints = isSync;
+//                _urmModeRecord.SetParameter(RecordParams.URMTracePoints, tracePoints);
+//            }
+
+//            private void ConvertAndUpload(DPoint[] tracePoints)
+//            {
+//                var tracePercentPoints = tracePoints.Select(x => _tissueAreaViewPort.ConvertBack(x)).ToArray();
+//                ((IDMVisual)_visual).SetDMParameter(_urmModeRecord, RecordParams.URMTracePoints, tracePercentPoints);
+//                if (_zoomFunction?.Running == true)
+//                {
+//                    _zoomFunction.GetVisualAreas(_visual.PrimaryTissueArea, out var slaveArea, out var masterArea);
+//                    var slaveTracePercentPoints = tracePoints.Select(x => slaveArea.ViewPort.ConvertBack(x)).ToArray();
+//                    var slaveManger = _zoomFunction.GetSlaveProcessManger();
+//                    ((IDMProcessManager)slaveManger).SetParameter(null, RecordParams.URMTracePoints, slaveTracePercentPoints);
+//                }
+//            }
+
+//            private DPoint[] GetTracePointsWithTilt(DPoint[] tracePoints, bool isSyncOfTracePoints, bool isSync, double urmLinearTilt, out bool isChanged)
+//            {
+//                if (_visual.Probe is LinearProbe && tracePoints.Length > 0)
+//                {
+//                    if (isSyncOfTracePoints != isSync)
+//                    {
+//                        isChanged = true;
+//                        var tilt = urmLinearTilt * 100;
+//                        tilt = isSyncOfTracePoints ? -tilt : tilt;
+//                        return tracePoints.Select(x => new DPoint(x.X + tilt, x.Y)).ToArray();
+//                    }
+//                }
+//                isChanged = false;
+//                return tracePoints;
+//            }
+
+//            public void SaveUrmVideo()
+//            {
+//                //if (_zoomFunction?.Running == true)
+//                //{
+//                //    _zoomFunction.ZoomStatus = ZoomStatus.None;
+//                //}
+//                _urmVideoSaver.SaveUrmVideo();
+//            }
+//        }
+
+//        private class UrmColorMapManager
+//        {
+//            private readonly Dictionary<string, string> _urmColorMaps;
+
+//            public UrmColorMapManager()
+//            {
+//                _urmColorMaps = new Dictionary<string, string>();
+//                LoadColorBarParams(_urmColorMaps);
+//            }
+
+//            private void LoadColorBarParams(Dictionary<string, string> urmColorMaps)
+//            {
+//                var colorConfigs = ResourceManager.GetValue("SRMap", "SRMap", string.Empty);
+//                if (!string.IsNullOrEmpty(colorConfigs))
+//                {
+//                    EnumMeta enumMeta = ParamMetaSection.CreateMeta(colorConfigs) as EnumMeta;
+//                    if (enumMeta?.Values.Length > 0)
+//                    {
+//                        foreach (var config in enumMeta.Values)
+//                        {
+//                            var elements = config.Split(' ');
+//                            if (elements.Length == 2)
+//                            {
+//                                var title = elements[0].Trim();
+//                                var mapConfigs = elements[1].Trim();
+//                                urmColorMaps.Add(title, mapConfigs);
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+
+//            public string GetAvailableColorMap(string title)
+//            {
+//                string colorMap = "Density";
+//                if (_urmColorMaps.ContainsKey(title))
+//                {
+//                    colorMap = _urmColorMaps[title];
+//                }
+//                return colorMap;
+//            }
+//        }
+
+//        private class UrmVideoSaver
+//        {
+//            private readonly IReplayVisual _visual;
+//            private IWizardManager _wizardManager;
+
+//            private Record _record;
+//            private ModeRecord _urmModeRecord;
+//            private URMAnalysisResultManager _urmManager;
+
+//            public UrmVideoSaver(IReplayVisual visual, UrmColorMapManager urmColorMapManager)
+//            {
+//                _visual = visual;
+//            }
+
+//            public void Initialize(IWizardManager wizardManager)
+//            {
+//                _wizardManager = wizardManager;
+//            }
+
+//            public void Activate(Record record, ModeRecord urmModeRecord)
+//            {
+//                _record = record;
+//                _urmModeRecord = urmModeRecord;
+
+//                _urmManager = new URMAnalysisResultManager(_visual, _urmModeRecord);
+//                _urmManager.URMVersionCompatible();
+//            }
+
+//            public void Deactivate()
+//            {
+//                _urmManager?.Dispose();
+//                _urmManager = null;
+//            }
+
+//            public void SaveUrmVideo()
+//            {
+//                _wizardManager.Startup("URM", "URMSaveWaiting", CreateURMVideoTask, double.NaN, WizardButtonEnum.None);
+//            }
+
+//            private void CreateURMVideoTask()
+//            {
+//                TaskManagerFactory.Instance.GetTaskManager("CreateURMVideoTask")
+//                    .StartNewTaskProxy("CreateURMVideoTask", CreateAndSaveURMVideo, OnURMVideoTaskFinished);
+//            }
+
+//            private void CreateAndSaveURMVideo(TaskProxy proxy)
+//            {
+//                var processManager =_visual as  IProcessManager;
+//                var outvel = processManager.ComputeParameter(RecordParams.URMVedioCal) as URMVedioTemp;
+//                var dstimgs = outvel.DstArray;
+//                var displayManager = ServiceManager.Instance.GetService<IDisplayManager>();
+//                ServiceManager.MainDispatcher.Invoke(() =>
+//                {
+//                    var bitmaps = new List<IBitmapSource>();
+//                    var aviframesize = outvel.Width * outvel.Height * 4;
+//                    var curptr = dstimgs.Start;
+//                    for (var i = 0; i < outvel.Frames; i++)
+//                    {
+//                        var curMatptr = curptr;
+//                        var bitmap = displayManager.CreateBitmapSource(outvel.Width, outvel.Height, 96, 96, VPixelFormat.V_Bgr32,
+//                            curMatptr, aviframesize, outvel.Width * 4);
+//                        bitmaps.Add(bitmap);
+//                        curptr = curMatptr + aviframesize;
+//                    }
+//                    SaveUrmVideo(bitmaps);
+//                    dstimgs.Dispose();
+//                });
+//            }
+
+//            private void OnURMVideoTaskFinished(TaskProxy proxy)
+//            {
+//                var manager = ServiceManager.Instance.GetService<IWizardManager>();
+//                using (manager.ClosingWizard())
+//                {
+//                    var showError = false;
+//                    if (proxy.Task.IsCanceled)
+//                    {
+//                        Logger.WriteLineInfo("Task:{0} is canceled.", proxy.Name);
+//                    }
+//                    else if (proxy.Task.Exception != null)
+//                    {
+//                        showError = true;
+//                        Logger.WriteLineError("Task:{0} failed, exception: {1}.", proxy.Name, proxy.Task.Exception);
+//                    }
+//                    if (!showError)
+//                    {
+//                        manager.Close();
+//                    }
+//                    else
+//                    {
+//                        manager.Close("ShowResults failed.", false);
+//                    }
+//                }
+//            }
+
+//            private void SaveUrmVideo(List<IBitmapSource> bitmaps)
+//            {
+//                var command = new ExtraCommand();
+//                command.Commands.Add(new StoreCommand<bool>(StoreParameterEnum.DisableAsyncStorage, true));
+//                command.Commands.Add(new StoreCommand<bool>(StoreParameterEnum.IsUrmVideo, true));
+//                command.Commands.Add(new StoreCommand<List<IBitmapSource>>(StoreParameterEnum.UrmVideoData, bitmaps));
+//                var clipboardService = ServiceManager.Instance.GetService<IClipboardService>();
+//                clipboardService.StoreImage(clipboardService.DefaultVrdConfiguration, command);
+//            }
+//        }
+
+//    }
+//}

URMPakcage/URM/URMFunction_CaptureDataManager.cs

@@ -0,0 +1,438 @@
+//using System;
+//using System.Linq;
+//using System.Windows.Threading;
+//using UtilityService;
+//using Vinno.DataManager;
+//using Vinno.DataManager.Data;
+//using Vinno.DataManager.ImageBuffer;
+//using Vinno.DataManager.Infrastructure;
+//using Vinno.DataManager.Modes;
+//using Vinno.DataManager.Records;
+//using Vinno.DataManager.Render;
+//using Vinno.Infrastructure;
+//using Vinno.Infrastructure.Enums;
+//using Vinno.Models.Base.Functions;
+//using Vinno.Models.Base.Modes;
+//using Vinno.Models.Base.Parameters;
+//using Vinno.Models.Base.Visuals;
+//using Vinno.Models.SpecificImpl.Functions.CBISync;
+//using Vinno.Models.Zoom;
+//using Vinno.Modules.ClipboardModule;
+
+//namespace Vinno.Models.AdditionalFeatures.Functions.URM
+//{
+//    public partial class URMFunction
+//    {
+//        private class CaptureDataManager
+//        {
+//            private readonly URMFunction _owner;
+//            private readonly IReplayVisual _visual;
+
+//            private UrmSampleRoiFunction _sampleRoiFunction;
+//            private ZoomFunction _zoomFunction;
+
+//            public CaptureDataManager(URMFunction owner)
+//            {
+//                _owner = owner;
+//                _visual = owner._visual;
+//            }
+
+//            public void Initialize(ZoomFunction zoomFunction)
+//            {
+//                _sampleRoiFunction = new UrmSampleRoiFunction(_visual);
+//                _zoomFunction = zoomFunction;
+//            }
+
+//            public void Activate()
+//            {
+//                _sampleRoiFunction.Activate(true);
+//                if (_zoomFunction != null)
+//                {
+//                    _zoomFunction.StateChanged += ZoomFunctionOnStateChanged;
+//                }
+//            }
+
+//            public void Deactivate()
+//            {
+//                _sampleRoiFunction.Activate(false);
+//                if (_zoomFunction != null)
+//                {
+//                    _zoomFunction.StateChanged -= ZoomFunctionOnStateChanged;
+//                }
+//            }
+
+//            private void ZoomFunctionOnStateChanged(object sender, EventArgs e)
+//            {
+//                if (_zoomFunction != null)
+//                {
+//                    if (_zoomFunction.ZoomStatus == ZoomStatus.None &&
+//                        _owner.UrmStatus == UrmStatus.CaptureData &&
+//                        !_sampleRoiFunction.IsActive)
+//                    {
+//                        _sampleRoiFunction.Activate(true);
+//                    }
+//                }
+//            }
+
+//            public void Analysis()
+//            {
+//                if (_zoomFunction?.Running == true)
+//                {
+//                    _zoomFunction.ZoomStatus = ZoomStatus.None;
+//                }
+//                _owner._wizardManager.Startup("URM", "Analysis", StartAnalysis, double.NaN, WizardButtonEnum.None);
+//            }
+
+//            private bool TryGetRenderRecord(IReplayVisual visual, out RenderRecord renderRecord)
+//            {
+//                if (visual.Tissue is IUrmCBI)
+//                {
+//                    var urmCbiSyncModeRecord = ((IDMVisual)visual).Record.Modes.FirstOrDefault(x => x.ModeName == N.UrmCBISync);
+//                    if (urmCbiSyncModeRecord != null)
+//                    {
+//                        renderRecord = urmCbiSyncModeRecord.RenderRecord;
+//                        return true;
+//                    }
+//                }
+
+//                if (visual.Tissue is IUrmTwoDMode urmTwoDMode)
+//                {
+//                    renderRecord = ((IDMMode) urmTwoDMode).ModeRecord.RenderRecord;
+//                    return true;
+//                }
+
+//                renderRecord = null;
+//                return false;
+//            }
+
+//            private void StartAnalysis()
+//            {
+//                var replayVisual = (ReplayVisual)_visual;
+//                if (TryGetRenderRecord(_visual, out var renderRecord) &&
+//                    replayVisual.TryAddMode(N.URM, renderRecord, out var mode) &&
+//                    mode is IURM urmMode &&
+//                    _sampleRoiFunction.TryGetRoiData(out var isLinear, out var roiBeanPosition, out var roiWidth, out var roiDepthStart, out var roiDepthEnd, out var roiImageWidth))
+//                {
+//                    UpdateParameter((IMode)urmMode, _visual.Tissue);
+//                    urmMode.UploadParameterDefaultValue();
+
+//                    var rawInputGridSize = GetRawInputGridSize(_visual);
+//                    var processingGridSize = GetProcessingGridSize(_visual);
+//                    var urmModeRecord = ((IDMMode)urmMode).ModeRecord;
+//                    var data = new BeginAnalysisData(_visual,
+//                        urmModeRecord,
+//                        isLinear,
+//                        roiBeanPosition,
+//                        roiWidth,
+//                        roiDepthStart,
+//                        roiDepthEnd,
+//                        roiImageWidth,
+//                        rawInputGridSize,
+//                        processingGridSize);
+
+//                    SetFrameInfo4URM(urmModeRecord);//给Rawinput添加一个frame 用于适配一些需要的场景
+//                    TaskManagerFactory.Instance.GetTaskManager("URMAnalysisTaskManager")
+//                        .StartNewTaskProxy("URMAnalysis", BeginAnalysis, OnURMAnalysisTaskFinished, data);
+//                }
+//                else
+//                {
+//                    _owner._wizardManager.Close("Analysis failed.", false);
+//                }
+//            }
+
+//            private void UpdateParameter(IMode urmMode, IMode fromMode)
+//            {
+//                var urmLevelParameter = urmMode.Parameters.GetItem<FloatParameter>(RecordParams.URMLevel);
+//                var urmStabilizerParameter = urmMode.Parameters.GetItem<FloatParameter>(RecordParams.URMStabilizer);
+//                var levelParameter = fromMode.Parameters.GetItem<FloatParameter>(RecordParams.URMLevel);
+//                var stabilizerParameter = fromMode.Parameters.GetItem<FloatParameter>(RecordParams.URMStabilizer);
+//                urmLevelParameter.Value = levelParameter.Value;
+//                urmStabilizerParameter.Value = stabilizerParameter.Value;
+//            }
+
+//            private IVector3D GetRawInputGridSize(IReplayVisual visual)
+//            {
+//                var time = ((ReplayVisual)visual).ProcessManager.CineController.CurrentTime;
+//                var frame = ((VrdModeBase)((ReplayVisual)visual).Tissue).ModeRecord.RawInput.GetFrame(new TimeStamp(time), false);
+//                return frame.GridSize;
+//            }
+//            private IVector3D GetProcessingGridSize(IReplayVisual visual)
+//            {
+//                var time = ((ReplayVisual)visual).ProcessManager.CineController.CurrentTime;
+//                var frame = ((VrdModeBase)((ReplayVisual)visual).Tissue).ModeRecord.ProcessingOutput.GetFrame(new TimeStamp(time), false);
+//                return frame.GridSize;
+//            }
+
+//            //Todo Workaround, when replay urm image without sync, it will cause crash to press Dual/Quad key.
+//            private void SetFrameInfo4URM(ModeRecord urmModeRecord)
+//            {
+//                var buffer = urmModeRecord.RawInput.GetFrameBuffer();
+//                urmModeRecord.RawInput.SetSampleType(SampleTypeEnum.Tissue_8);
+//                if (buffer == null)
+//                {
+//                    buffer = new FrameBuffer(urmModeRecord.RawInput);
+//                }
+//                var frame = buffer.AllocateFrame(TimeStamp.ErrorTime, new IVector3D(1, 1), 1, SampleTypeEnum.Tissue_8);
+//                buffer.InsertFrame(frame);
+//            }
+
+//            private void BeginAnalysis(TaskProxy proxy)
+//            {
+//                if (!(proxy.Tag is BeginAnalysisData data))
+//                {
+//                    throw new ArgumentNullException("Failed to get roi data.");
+//                }
+
+//                var urmModeRecord = data.UrmModeRecord;
+//                var roiBeanPosition = data.RoiBeanPosition;
+//                var roiWidth = data.RoiWidth;
+//                var roiDepthStart = data.RoiDepthStart;
+//                var roiDepthEnd = data.RoiDepthEnd;
+//                var rawInputGridSize = data.RawInputGridSize;
+//                var processingGridSize = data.ProcessingGridSize;
+
+//                var urmManager = new URMAnalysisManager(_visual, urmModeRecord);
+//                //根据ROI给URMmoderecord设置参数
+//                if (data.IsLinear)
+//                {
+//                    int beamStart, beamEnd, sampleStart, sampleEnd;
+//                    float depthEnd = _visual.Tissue.Parameters.GetItem<FloatParameter>(RecordParams.ScanMaxDepth).Value;
+//                    float depthStart = _visual.Tissue.Parameters.GetItem<FloatParameter>(RecordParams.ScanMinDepth).Value;
+//                    //宽度（单位归一化比）-0.5 到0.5
+//                    beamStart = (int)Math.Round((roiBeanPosition + 0.5 - roiWidth / 2) * rawInputGridSize.Beams);
+//                    beamEnd = (int)Math.Round((roiBeanPosition + 0.5 + roiWidth / 2) * rawInputGridSize.Beams);
+//                    sampleStart = (int)Math.Round((roiDepthStart - depthStart) / (depthEnd - depthStart) * rawInputGridSize.Samples);
+//                    sampleEnd = (int)Math.Round((roiDepthEnd - depthStart) / (depthEnd - depthStart) * rawInputGridSize.Samples);
+//                    var clipboardService = ServiceManager.Instance.GetService<IClipboardService>();
+//                    var clipImage = clipboardService.GetClipImage(_visual);
+//                    //todo:Joker for matlab analysis  Point Index +1
+//                    urmManager.UpdateParms(beamStart+1, beamEnd+1, sampleStart+1, sampleEnd+1, clipImage);
+//                    int beamStartout, beamEndout, sampleStartout, sampleEndout;
+//                    beamStartout = (int)Math.Round((roiBeanPosition + 0.5 - roiWidth / 2) * processingGridSize.Beams);
+//                    beamEndout = (int)Math.Round((roiBeanPosition + 0.5 + roiWidth / 2) * processingGridSize.Beams);
+//                    sampleStartout = (int)Math.Round((roiDepthStart - depthStart) / (depthEnd - depthStart) * processingGridSize.Samples);
+//                    sampleEndout = (int)Math.Round((roiDepthEnd - depthStart) / (depthEnd - depthStart) * processingGridSize.Samples);
+//                    var urmBeamPosition = roiBeanPosition * (data.RoiImageWidth / 2);
+//                    SetURMModeRecord(urmModeRecord, processingGridSize,
+//                        beamStartout, beamEndout, sampleStartout, sampleEndout, urmBeamPosition);
+//                }
+//                else
+//                {
+//                    int beamStart, beamEnd, sampleStart, sampleEnd;
+//                    float depthEnd = _visual.Tissue.Parameters
+//                        .GetItem<FloatParameter>(RecordParams.ScanMaxDepth).Value;
+//                    float depthStart = _visual.Tissue.Parameters
+//                        .GetItem<FloatParameter>(RecordParams.ScanMinDepth).Value;
+//                    var ProcessCache = ((VrdModeBase)((ReplayVisual)_visual).Tissue).ModeRecord.ProcessingOutput;
+//                    var scanwidth = ProcessCache.GetDirectValue(RecordParams.ScanMaxWidth, TimeStamp.LastTime, 0d);
+//                    scanwidth *= (180.0 / Math.PI);//转换为角度
+//                                                   // 角度（单位：度）-20到20
+//                    beamStart = (int)Math.Round(((roiBeanPosition + scanwidth / 2 - roiWidth / 2) / scanwidth * rawInputGridSize.Beams));
+//                    beamEnd = (int)Math.Round(((roiBeanPosition + scanwidth / 2 + roiWidth / 2) / scanwidth * rawInputGridSize.Beams));
+//                    sampleStart = (int)Math.Round(((roiDepthStart - depthStart) / (depthEnd - depthStart) * rawInputGridSize.Samples));
+//                    sampleEnd = (int)Math.Round(((roiDepthEnd - depthStart) / (depthEnd - depthStart) * rawInputGridSize.Samples));
+//                    var clipboardService = ServiceManager.Instance.GetService<IClipboardService>();
+//                    var clipImage = clipboardService.GetClipImage(_visual);
+//                    //todo:Joker for matlab analysis  Point Index +1
+//                    urmManager.UpdateParms(beamStart +1, beamEnd  +1, sampleStart +1, sampleEnd+1, clipImage);
+//                    int beamStartout, beamEndout, sampleStartout, sampleEndout;
+//                    beamStartout = (int)Math.Round(((roiBeanPosition + scanwidth / 2 - roiWidth / 2) / scanwidth * processingGridSize.Beams));
+//                    beamEndout = (int)Math.Round(((roiBeanPosition + scanwidth / 2 + roiWidth / 2) / scanwidth * processingGridSize.Beams));
+//                    sampleStartout = (int)Math.Round(((roiDepthStart - depthStart) / (depthEnd - depthStart) * processingGridSize.Samples));
+//                    sampleEndout = (int)Math.Round(((roiDepthEnd - depthStart) / (depthEnd - depthStart) * processingGridSize.Samples));
+//                    var urmBeamPosition = roiBeanPosition * Math.PI / 180;
+//                    SetURMModeRecord(urmModeRecord, processingGridSize,
+//                        beamStartout, beamEndout, sampleStartout, sampleEndout, urmBeamPosition);
+//                }
+
+//                bool success = urmManager.UrmAnalysis();
+//                urmManager.Dispose();
+//                if (success)
+//                {
+//                    ServiceManager.MainDispatcher.BeginInvoke(VDispatcherPriority.Background, FinishAnalysis);
+//                }
+//                else
+//                {
+//                    Logger.WriteLineError("URMFunction: Failed to analyze.");
+//                    _owner._wizardManager.Close("Analysis failed.", false);
+//                }
+//            }
+
+//            private void OnURMAnalysisTaskFinished(TaskProxy proxy)
+//            {
+//                if (proxy.IsFaulted)
+//                {
+//                    Logger.WriteLineError("Task:{0} failed, exception: {1}.", proxy.Name, proxy.Task.Exception);
+//                    _owner._wizardManager.Close("Analysis failed.", false);
+//                }
+//            }
+
+//            private void SetURMModeRecord(ModeRecord urmModeRecord, IVector3D processingGridSize,
+//                int beamStart, int beamEnd, int sampleStart, int sampleEnd, double urmBeamPosition)
+//            {
+//                var ProcessCache = ((VrdModeBase)((ReplayVisual)_visual).Tissue).ModeRecord.ProcessingOutput;
+//                int width = beamEnd - beamStart;
+//                int height = sampleEnd - sampleStart;
+//                var urmoutGridSzie = new IVector3D(height, width);
+//                urmModeRecord.SetParameter(RecordParams.URMOutGridSize, urmoutGridSzie);
+//                var tissueWidth = ProcessCache.GetDirectValue(RecordParams.ScanMaxWidth, TimeStamp.LastTime, 0d);
+//                var depthStart = ProcessCache.GetDirectValue(RecordParams.ScanMinDepth, TimeStamp.LastTime, 0d);
+//                var depthEnd = ProcessCache.GetDirectValue(RecordParams.ScanMaxDepth, TimeStamp.LastTime, 0d);
+//                var roiStart = depthStart + sampleStart * (depthEnd - depthStart) / processingGridSize.Samples;
+//                var roiEnd = Math.Min(depthEnd, depthStart + sampleEnd * (depthEnd - depthStart) / processingGridSize.Samples);
+//                var roiWidth = Math.Min(tissueWidth, tissueWidth * width / processingGridSize.Beams);
+//                var vectorAngles = new double[width];
+//                var dmVisual = (IDMMode)_visual.Tissue;
+//                var variableVectorSpacing = dmVisual.ModeRecord.GetDirectValue(
+//                    RecordParams.SpcTr_isTrueLineGeometry, TimeStamp.LastTime, false, false);
+//                if (variableVectorSpacing)
+//                {
+//                    double[] beamVar = dmVisual.ModeRecord.GetDirectValue(RecordParams.SpcTr_lineScanAngles, TimeStamp.LastTime, new double[0]);
+//                    if (beamVar.Length == processingGridSize.Beams)
+//                    {
+//                        for (int i = beamStart; i < beamEnd; i++)
+//                        {
+//                            vectorAngles[i - beamStart] = beamVar[i];
+//                        }
+//                    }
+//                    else
+//                    {
+//                        variableVectorSpacing = false;
+//                    }
+//                }
+
+//                if (!variableVectorSpacing)
+//                {
+//                    for (int i = beamStart; i < beamEnd; i++)
+//                    {
+//                        vectorAngles[i - beamStart] = tissueWidth * i / processingGridSize.Beams - tissueWidth / 2;
+//                    }
+//                }
+//                var tilt = (vectorAngles[0] + vectorAngles[vectorAngles.Length - 1]) / 2;
+//                var linearScan = dmVisual.ModeRecord.GetDirectValue(RecordParams.SpcTr_isLinearGeom, false, false);
+//                urmModeRecord.SetParameter(RecordParams.SpcTr_isLinearGeom, linearScan);
+//                var urmCache = urmModeRecord.ProcessingOutput;
+//                urmCache.SetSampleType(SampleTypeEnum.Tissue_8);
+//                urmCache.SetParameter(RecordParams.TransGridSize, new IVector3D(height, width));
+//                urmModeRecord.SetParameter(RecordParams.ScanMinDepth, roiStart);
+//                urmCache.SetParameter(RecordParams.ScanMaxDepth, roiEnd);
+//                urmModeRecord.SetParameter(RecordParams.ScanMaxDepth, roiEnd);
+//                urmCache.SetParameter(RecordParams.ScanMaxWidth, roiWidth);
+//                urmModeRecord.SetParameter(RecordParams.ScanMaxWidth, roiWidth);
+//                urmModeRecord.SetParameter(RecordParams.ProbeWidth, roiWidth);
+//                urmCache.SetParameter(RecordParams.LineBufferSize, height);
+//                urmModeRecord.SetParameter(RecordParams.LineBufferSize, height);
+//                urmCache.SetParameter(RecordParams.SpcTr_lineScanAngles, vectorAngles);
+//                urmModeRecord.SetParameter(RecordParams.SpcTr_lineScanAngles, vectorAngles);
+//                urmCache.SetParameter(RecordParams.BeamPosition, urmBeamPosition);
+//                urmModeRecord.SetParameter(RecordParams.BeamPosition, urmBeamPosition);
+
+//                if (linearScan)
+//                {
+//                    urmModeRecord.SetParameter(RecordParams.UrmLinearTilt, tilt);
+
+//                    var steer = ProcessCache.GetParameter<double>(RecordParams.SAngle);
+//                    urmCache.SetParameter(RecordParams.SAngle, steer);
+//                    urmCache.SetParameter(RecordParams.SpcTr_HorOrigin, tilt);
+//                    urmCache.SetParameter(RecordParams.SpcTr_NorOrigin, 0d);
+//                    urmCache.SetParameter(RecordParams.SSTilt, 0d);
+//                    urmModeRecord.SetParameter(RecordParams.SAngle, steer);
+//                    urmModeRecord.SetParameter(RecordParams.SpcTr_HorOrigin, tilt);
+//                    urmModeRecord.SetParameter(RecordParams.SpcTr_NorOrigin, 0d);
+//                    urmModeRecord.SetParameter(RecordParams.SSTilt, 0d);
+//                }
+//                else
+//                {
+//                    urmCache.SetParameter(RecordParams.SAngle, tilt);
+//                    urmCache.SetParameter(RecordParams.SSTilt, tilt);
+//                    urmCache.SetParameter(RecordParams.SpcTr_HorOrigin, 0d);
+//                    var origoZ = ProcessCache.GetParameter<double>(RecordParams.SpcTr_NorOrigin);
+//                    urmCache.SetParameter(RecordParams.SpcTr_NorOrigin, origoZ);
+//                    urmModeRecord.SetParameter(RecordParams.SAngle, tilt);
+//                    urmModeRecord.SetParameter(RecordParams.SSTilt, tilt);
+//                    urmModeRecord.SetParameter(RecordParams.SpcTr_HorOrigin, 0d);
+//                    urmModeRecord.SetParameter(RecordParams.SpcTr_NorOrigin, origoZ);
+//                }
+//                urmModeRecord.SetParameter(RecordParams.URMFlag, true);
+//                var urmvesion = ResourceManager.GetValue("Product-OptionalFeatures", "URMProcessVersion", 3.1);
+//                urmModeRecord.SetParameter(RecordParams.URMProcessVersion, urmvesion);
+//            }
+
+//            private void FinishAnalysis()
+//            {
+//                if (_visual.Tissue is IUrmCBI)
+//                {
+//                    var syncFunction = _visual.SupportedFunctions.TryGetItem(CBISyncDisplayFunction.Id) as CBISyncDisplayFunction;
+//                    if (syncFunction != null && syncFunction.Running)
+//                    {
+//                        syncFunction.Running = false;
+//                    }
+
+//                    var copyRecord = Record.CopyRecord(((IDMVisual)_visual).Record, TimeInterval.WholeTimeAxis, "DeepCopy", 0.0);
+//                    var urmCbiModeRecord = copyRecord.Modes.FirstOrDefault(x => x.ModeName == N.UrmCBI);
+//                    var urmCbiSyncModeRecord = copyRecord.Modes.FirstOrDefault(x => x.ModeName == N.UrmCBISync);
+//                    if (urmCbiModeRecord != null && urmCbiSyncModeRecord != null)
+//                    {
+//                        urmCbiSyncModeRecord.RenderRecord.SetParameter(ParamCategoryEnum.UIControls, RecordParams.SlaveProcessManager, false);
+//                        urmCbiSyncModeRecord.RenderRecord.SetParameter(ParamCategoryEnum.UIControls, RecordParams.CBISyncDisplay, false);
+//                        copyRecord.RemoveModeRecord(urmCbiModeRecord);
+//                        using (_owner._analysisProcessingBreaker.PauseProcessing())
+//                        {
+//                            //Todo SetRecord will tigger OnProbeChanged of _owner, it equal replay the analyzed urm image.
+//                            ((ReplayVisual)_visual).SetRecord(copyRecord);
+//                        }
+//                    }
+//                }
+//                else
+//                {
+//                    var copyRecord = Record.CopyRecord(((IDMVisual)_visual).Record, TimeInterval.WholeTimeAxis, "DeepCopy", 0.0);
+//                    using (_owner._analysisProcessingBreaker.PauseProcessing())
+//                    {
+//                        //Todo SetRecord will tigger OnProbeChanged of _owner, it equal replay the analyzed urm image.
+//                        ((ReplayVisual)_visual).SetRecord(copyRecord);
+//                    }
+//                }
+
+//                _owner._wizardManager.Close();
+//            }
+//        }
+
+//        public class BeginAnalysisData
+//        {
+//            public IReplayVisual Visual { get; }
+//            public ModeRecord UrmModeRecord { get; }
+//            public bool IsLinear { get; }
+//            public double RoiBeanPosition { get; }
+//            public double RoiWidth { get; }
+//            public double RoiDepthStart { get; }
+//            public double RoiDepthEnd { get; }
+//            public double RoiImageWidth { get; }
+//            public IVector3D RawInputGridSize { get; }
+//            public IVector3D ProcessingGridSize { get; }
+
+//            public BeginAnalysisData(IReplayVisual visual,
+//                ModeRecord urmModeRecord,
+//                bool isLinear,
+//                double roiBeanPosition,
+//                double roiWidth,
+//                double roiDepthStart,
+//                double roiDepthEnd,
+//                double roiImageWidth,
+//                IVector3D rawInputGridSize,
+//                IVector3D processingGridSize)
+//            {
+//                Visual = visual;
+//                UrmModeRecord = urmModeRecord;
+//                IsLinear = isLinear;
+//                RoiBeanPosition = roiBeanPosition;
+//                RoiWidth = roiWidth;
+//                RoiDepthStart = roiDepthStart;
+//                RoiDepthEnd = roiDepthEnd;
+//                RoiImageWidth = roiImageWidth;
+//                RawInputGridSize = rawInputGridSize;
+//                ProcessingGridSize = processingGridSize;
+//            }
+//        }
+
+//    }
+//}

URMPakcage/URM/URMFunction_TraceManager.cs

@@ -0,0 +1,161 @@
+//using System;
+//using System.Linq;
+//using Vinno.Infrastructure;
+//using Vinno.Infrastructure.Media;
+//using Vinno.Models.Base.VisualAreas;
+//using Vinno.Models.Base.Visuals;
+//using Vinno.Models.Zoom;
+//using Vinno.Modules.CBI;
+//using Vinno.Modules.MeasureModule;
+//using Vinno.Modules.RenderModule;
+//using Vinno.Modules.RenderModule.CustomEventArgs;
+//using Vinno.Services.InputServices;
+
+//namespace Vinno.Models.AdditionalFeatures.Functions.URM
+//{
+//    public partial class URMFunction
+//    {
+//        private class TraceManager
+//        {
+//            private readonly URMFunction _owner;
+//            private readonly IReplayVisual _visual;
+
+//            private ICursorService _cursorService;
+//            private IMeasureService _measureService;
+//            private ZoomFunction _zoomFunction;
+
+//            private IRenderService _renderService;
+
+//            private CurveRegion _currentCurveRegion;
+//            private IVisualArea _currentVisualArea;
+
+//            private bool _isActive;
+
+//            public bool IsActive
+//            {
+//                get { return _isActive; }
+//                private set
+//                {
+//                    if (_isActive != value)
+//                    {
+//                        _isActive = value;
+//                        _owner.OnIsTraceActiveChange();
+//                    }
+//                }
+//            }
+
+//            private bool IsDrawing => _currentCurveRegion?.DrawingMode == true;
+
+//            public TraceManager(URMFunction owner)
+//            {
+//                _owner = owner;
+//                _visual = owner._visual;
+//            }
+
+//            public void Initialize(ZoomFunction zoomFunction)
+//            {
+//                _cursorService = ServiceManager.Instance.GetService<ICursorService>();
+//                _measureService = ServiceManager.Instance.GetService<IMeasureService>();
+//                _zoomFunction = zoomFunction;
+
+//                _renderService = ServiceManager.Instance.GetService<IRenderService>();
+//            }
+
+//            public void Activate()
+//            {
+//                _cursorService.CursorStateChanged += OnStateChanged;
+//                _measureService.IsMeasureRunningChanged += OnStateChanged;
+//                if (_zoomFunction != null)
+//                {
+//                    _zoomFunction.StateChanged += OnStateChanged;
+//                }
+
+//                _renderService.PositionChanged += OnPositionChanged;
+
+//                IsActive = true;
+//            }
+
+//            public void Deactivate()
+//            {
+//                if (IsDrawing)
+//                {
+//                    FinishDrawing();
+//                }
+
+//                _cursorService.CursorStateChanged -= OnStateChanged;
+//                _measureService.IsMeasureRunningChanged -= OnStateChanged;
+//                if (_zoomFunction != null)
+//                {
+//                    _zoomFunction.StateChanged -= OnStateChanged;
+//                }
+
+//                _renderService.PositionChanged -= OnPositionChanged;
+
+//                IsActive = false;
+//            }
+
+//            private void OnStateChanged(object sender, EventArgs e)
+//            {
+//                if (IsActive)
+//                {
+//                    Deactivate();
+//                }
+//            }
+
+//            private void OnPositionChanged(object sender, VisualAreaEventArgs e)
+//            {
+//                IVisualArea visualArea = e.PointInfo.VisualArea;
+//                if (e.PointInfo.Action == PointAction.MouseDown)
+//                {
+//                    if (IsDrawing)
+//                    {
+//                        FinishDrawing();
+//                        Deactivate();
+//                    }
+//                    else
+//                    {
+//                        _currentVisualArea = visualArea;
+//                        StartDrawing();
+//                    }
+//                }
+//                else if (e.PointInfo.Action == PointAction.MouseMove)
+//                {
+//                    if (_currentVisualArea != visualArea)
+//                    {
+//                        return;
+//                    }
+//                    if (IsDrawing)
+//                    {
+//                        Draw(e.PointInfo);
+//                    }
+//                }
+//            }
+
+//            private void StartDrawing()
+//            {
+//                _currentCurveRegion = new CurveRegion(VColors.White)
+//                {
+//                    StrokeThickness = 4
+//                };
+//                _currentCurveRegion.StartDrawing();
+//                _visual.PrimaryTissueArea.AddSychroAdorner(_currentCurveRegion);
+//            }
+
+//            private void FinishDrawing()
+//            {
+//                _owner._analysisResultManager.CutImage(_currentCurveRegion.TracePoints.ToArray());
+
+//                _visual.PrimaryTissueArea.RemoveSychroAdorner(_currentCurveRegion);
+//                _currentCurveRegion.FinishDrawing();
+//                _currentCurveRegion = null;
+//                _currentVisualArea = null;
+//            }
+
+//            private void Draw(PointInfo pointInfo)
+//            {
+//                _currentCurveRegion.UpdateDrawing(pointInfo.LogicPoint);
+//            }
+
+//        }
+//    }
+//}

URMPakcage/URM/URMManager.cs

@@ -0,0 +1,109 @@
+//using System;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Runtime.InteropServices;
+//using Vinno.DataManager.Data;
+//using Vinno.DataManager.Infrastructure;
+//using Vinno.DataManager.Modes;
+//using Vinno.DataManager.Utilities;
+//using Vinno.DataTypes;
+//using Vinno.Infrastructure;
+//using Vinno.Infrastructure.Collections;
+//using Vinno.Models.Base.Modes;
+//using Vinno.Models.Base.Visuals;
+//using Vinno.Modules.ClipboardModule.Models;
+
+////URM分析 
+//namespace Vinno.Models.AdditionalFeatures.Functions.URM
+//{
+//    public class URMAnalysisManager : IDisposable
+//    {
+//        private readonly IVisual _visual;
+//        private readonly ModeRecord _urmModeRecord;
+
+//        private readonly URMFileIO _urmFileIo;
+//        private readonly URMAnalysisProcess _urmAnalysisProcess;
+
+//        private string _posxmlfold;
+
+//        public URMAnalysisManager(IVisual visual, ModeRecord urmModeRecord)
+//        {
+//            _visual = visual;
+//            _urmModeRecord = urmModeRecord;
+
+//            var mode = _visual.Tissue;
+//            var ipp = ((IDMVisual)_visual).Record.ImagePP;
+//            _urmFileIo = new URMFileIO(mode, _urmModeRecord, ipp);
+//            var dmmode = mode as IDMMode;
+//            var moderecord = dmmode?.ModeRecord;
+//            if (moderecord != null)
+//            {
+//                _urmAnalysisProcess = new URMAnalysisProcess(mode, _urmModeRecord);
+//                moderecord.TryGetParameter<string>(RecordParams.URMDataFold, "", out _posxmlfold, TimeStamp.LastTime);
+//            }
+//        }
+
+//        public void UpdateParms(int beamstart, int beamend, int samplestart, int sampleend, IClipImageSource clipimage)
+//        {
+//            _urmFileIo.UpdateParamPosJson(beamstart, samplestart, (beamend - beamstart), (sampleend - samplestart), clipimage, out _posxmlfold);
+//        }
+
+//        public bool UrmAnalysis()
+//        {
+//            return _urmAnalysisProcess.URMAnalysis(_posxmlfold);
+//        }
+
+//        public void Dispose()
+//        {
+//            _urmAnalysisProcess.Release();
+//        }
+//    }
+
+//    public class URMAnalysisResultManager
+//    {
+//        private readonly IVisual _visual;
+//        private readonly ModeRecord _urmModeRecord;
+//        private readonly URMAnalysisProcess _urmAnalysisProcess;
+
+
+//        public URMAnalysisResultManager(IVisual visual, ModeRecord urmModeRecord)
+//        {
+//            _visual = visual;
+//            _urmModeRecord = urmModeRecord;
+
+//            var mode = _visual.Tissue;
+//            _urmAnalysisProcess = new URMAnalysisProcess(mode, _urmModeRecord);
+//        }
+//        public void Dispose()
+//        {
+//            _urmAnalysisProcess.Release();
+//        }
+
+//        public void URMVersionCompatible()
+//        {
+//            var recordveersion = _urmModeRecord.GetParameter(RecordParams.URMProcessVersion, 2.1);
+
+//            if (recordveersion < 3.1)
+//            {
+//                var urmbeam = _urmModeRecord.GetParameter<int>(RecordParams.URMSrcWidth);
+//                var urmsample = _urmModeRecord.GetParameter<int>(RecordParams.URMSrcHeight);
+//                var denarray = _urmModeRecord.GetParameter<RecordNativeArray>(RecordParams.URMDenArray);
+//                _urmAnalysisProcess.TransposeImg(denarray.Start, urmbeam, urmsample);
+//                _urmModeRecord.SetParameter(RecordParams.URMDenArray, denarray);
+//                var dirarray = _urmModeRecord.GetParameter<RecordNativeArray>(RecordParams.URMDirArray);
+//                _urmAnalysisProcess.TransposeImg(dirarray.Start, urmbeam, urmsample);
+//                _urmModeRecord.SetParameter(RecordParams.URMDirArray, dirarray);
+//                var velarray = _urmModeRecord.GetParameter<RecordNativeArray>(RecordParams.URMVelArray);
+//                _urmAnalysisProcess.TransposeImg(velarray.Start, urmbeam, urmsample);
+//                _urmModeRecord.SetParameter(RecordParams.URMVelArray, velarray);
+//                RecordNativeArray mask = new RecordNativeArray(urmbeam * urmsample * sizeof(byte));
+//                byte[] byteArray = Enumerable.Repeat((byte)1, urmbeam * urmsample).ToArray();
+//                Marshal.Copy(byteArray, 0, mask.Start, urmbeam * urmsample * sizeof(byte));
+//                _urmModeRecord.SetParameter(RecordParams.URMMask, mask);
+//                var urmvesion = ResourceManager.GetValue("Product-OptionalFeatures", "URMProcessVersion", 3.1);
+//                _urmModeRecord.SetParameter(RecordParams.URMProcessVersion, urmvesion);
+//            }
+//        }
+
+//    }
+//}

URMPakcage/URM/UrmSampleRoi.cs

@@ -0,0 +1,138 @@
+//using Vinno.DataManager.Infrastructure;
+//using Vinno.Infrastructure.Collections;
+//using Vinno.Models.Adorners.RoiLayers;
+//using Vinno.Models.Adorners.Rois;
+//using Vinno.Models.Adorners.Rois.MovementController;
+//using Vinno.Models.Adorners.Rois.RoiBoundaryGenerators;
+//using Vinno.Models.Adorners.Rois.RoiComponent;
+//using Vinno.Models.Adorners.Rois.TissueRoi;
+//using Vinno.Models.Base.Modes;
+//using Vinno.Models.Base.Parameters;
+//using Vinno.Models.Base.Visuals;
+//using Vinno.Models.SpecificImpl.Probes;
+
+//namespace Vinno.Models.AdditionalFeatures.Functions.URM
+//{
+//    public class UrmSampleLinearRoi : LinearRoi
+//    {
+//        public UrmSampleLinearRoi(IVisual visual, IComponentRegistry tokens) : base(visual, tokens)
+//        {
+//        }
+//    }
+
+//    public class UrmSampleConvexRoi : ConvexRoi
+//    {
+//        public UrmSampleConvexRoi(IVisual visual, IComponentRegistry componentRegistry) : base(visual, componentRegistry, false)
+//        {
+//        }
+//    }
+
+//    #region Linear
+
+//    public class UrmSampleLinearRoiRegistry : ComponentRegistry
+//    {
+//        public UrmSampleLinearRoiRegistry(IVisual visual) : base(visual)
+//        {
+//        }
+
+//        protected override void RegisterImpl()
+//        {
+//            DataAccessor = Factory.RegisterInstance(new UrmSampleLinearRoiDataAccessor());
+//            MovementController = Factory.RegisterInstance(new LinearRoiMovementController(Visual, false));
+//            BoundaryGenerator = Factory.RegisterInstance(new LinearRoiBoundaryGenerator());
+//        }
+//    }
+
+//    public class UrmSampleLinearRoiDataAccessor : LinearTissueRoiDataAccessor
+//    {
+//        public override string TypeId => "UrmSampleLinearRoiDataAccessor";
+
+//        public override IReadableList<FloatParameter> GetRoiParameters(IAdorner roi)
+//        {
+//            return RoiParameterHost.GetUrmRoiParameters((Roi)roi, true);
+//        }
+
+//        public override void Initialize(IAdorner roi)
+//        {
+//            InitializeRoiData(roi);
+//        }
+
+//        public override bool Download(IAdorner roi)
+//        {
+//            InitializeRoiData(roi);
+//            return true;
+//        }
+
+//        private void InitializeRoiData(IAdorner roi)
+//        {
+//            var linearRoi = (UrmSampleLinearRoi)roi;
+//            if (linearRoi.Visual.Tissue is IMode mode &&
+//                linearRoi.Visual.Probe is LinearProbe linearProbe)
+//            {
+//                float depthEnd = mode.Parameters.GetItem<FloatParameter>(RecordParams.ScanMaxDepth).Value;
+//                float depthStart = mode.Parameters.GetItem<FloatParameter>(RecordParams.ScanMinDepth).Value;
+//                linearRoi.LinearData.RoiCenter = (depthStart + depthEnd) / 2;
+//                linearRoi.LinearData.RoiSpan = (depthEnd - depthStart) * 0.2;
+//                linearRoi.LinearData.BeamPosition = 0;
+//                linearRoi.LinearData.Width = 0.2;
+//                linearRoi.LinearData.ImageWidth = linearProbe.ProbeWidth;
+//            }
+//        }
+//    }
+
+//    #endregion
+
+//    #region Convex
+
+//    public class UrmSampleConvexRoiRegistry : ComponentRegistry
+//    {
+//        public UrmSampleConvexRoiRegistry(IVisual visual) : base(visual)
+//        {
+//        }
+
+//        protected override void RegisterImpl()
+//        {
+//            DataAccessor = Factory.RegisterInstance(new UrmSampleConvexRoiDataAccessor());
+//            MovementController = Factory.RegisterInstance(new ConvexRoiMovementController(Visual, false));
+//            BoundaryGenerator = Factory.RegisterInstance(new ConvexRoiBoundaryGenerator(false));
+//        }
+//    }
+
+//    public class UrmSampleConvexRoiDataAccessor : ConvexTissueRoiDataAccessor
+//    {
+//        public override string TypeId => "UrmSampleConvexRoiDataAccessor";
+
+//        public override IReadableList<FloatParameter> GetRoiParameters(IAdorner roi)
+//        {
+//            return RoiParameterHost.GetUrmRoiParameters((Roi)roi, false);
+//        }
+
+//        public override void Initialize(IAdorner roi)
+//        {
+//            InitializeRoiData(roi);
+//        }
+
+//        public override bool Download(IAdorner roi)
+//        {
+//            InitializeRoiData(roi);
+//            return true;
+//        }
+
+//        private void InitializeRoiData(IAdorner roi)
+//        {
+//            var convexRoi = (UrmSampleConvexRoi)roi;
+//            if (convexRoi.Visual.Tissue is IMode mode)
+//            {
+//                float depthEnd = mode.Parameters.GetItem<FloatParameter>(RecordParams.ScanMaxDepth).Value;
+//                float depthStart = mode.Parameters.GetItem<FloatParameter>(RecordParams.ScanMinDepth).Value;
+//                convexRoi.ConvexData.RoiCenter = (depthStart + depthEnd) / 2;
+//                convexRoi.ConvexData.RoiSpan = (depthEnd - depthStart) * 0.2;
+//                convexRoi.ConvexData.BeamPosition = 0;
+//                convexRoi.ConvexData.Width = 10;
+//            }
+//        }
+//    }
+
+//    #endregion
+
+//}

URMPakcage/URM/UrmSampleRoiFunction.cs

@@ -0,0 +1,88 @@
+//using Vinno.Models.Adorners.Rois.TissueRoi;
+//using Vinno.Models.Base.Visuals;
+//using Vinno.Models.SpecificImpl.Probes;
+
+//namespace Vinno.Models.AdditionalFeatures.Functions.URM
+//{
+//    public class UrmSampleRoiFunction : TissueRoiFunctionBase
+//    {
+//        private readonly UrmSampleLinearRoi _linearRoi;
+//        private readonly UrmSampleConvexRoi _convexRoi;
+
+//        public bool IsActive
+//        {
+//            get { return _linearRoi.Active || _convexRoi.Active; }
+//        }
+
+//        public UrmSampleRoiFunction(IVisual visual) : base(visual)
+//        {
+//            _linearRoi = new UrmSampleLinearRoi(visual, new UrmSampleLinearRoiRegistry(visual)) { IsVisible = false };
+//            _convexRoi = new UrmSampleConvexRoi(visual, new UrmSampleConvexRoiRegistry(visual)) { IsVisible = false };
+//            RoiLayer.RegisterTissueRoi(_linearRoi);
+//            RoiLayer.RegisterTissueRoi(_convexRoi);
+//        }
+
+//        public override void MoveEnd()
+//        {
+//        }
+
+//        public void Activate(bool active)
+//        {
+//            if (RoiLayer == null) return;
+
+//            Enabled = active;
+//            if (active)
+//            {
+//                RoiLayer.Function = this;
+//                RoiLayer.CanEnableRoiSize = true;
+//            }
+
+//            if (Visual.Probe is ConvexProbe)
+//            {
+//                _linearRoi.Active = false;
+//                _convexRoi.Active = active;
+//            }
+//            else
+//            {
+//                _linearRoi.Active = active;
+//                _convexRoi.Active = false;
+//            }
+
+//            _linearRoi.Data.NeedUpdate = true;
+//            _convexRoi.Data.NeedUpdate = true;
+//        }
+
+//        public bool TryGetRoiData(out bool isLinear, out double roiBeanPosition, out double roiWidth, out double roiDepthStart, out double roiDepthEnd, out double roiImageWidth)
+//        {
+//            if (_linearRoi.Active)
+//            {
+//                isLinear = true;
+//                roiBeanPosition = _linearRoi.LinearData.BeamPosition;
+//                roiWidth = _linearRoi.LinearData.Width;
+//                roiDepthStart = _linearRoi.LinearData.DepthStart;
+//                roiDepthEnd = _linearRoi.LinearData.DepthEnd;
+//                roiImageWidth = _linearRoi.LinearData.ImageWidth;
+//                return true;
+//            }
+
+//            if (_convexRoi.Active)
+//            {
+//                isLinear = false;
+//                roiBeanPosition = _convexRoi.ConvexData.BeamPosition;
+//                roiWidth = _convexRoi.ConvexData.Width;
+//                roiDepthStart = _convexRoi.ConvexData.DepthStart;
+//                roiDepthEnd = _convexRoi.ConvexData.DepthEnd;
+//                roiImageWidth = 0;
+//                return true;
+//            }
+
+//            isLinear = false;
+//            roiBeanPosition = 0;
+//            roiWidth = 0;
+//            roiDepthStart = 0;
+//            roiDepthEnd = 0;
+//            roiImageWidth = 0;
+//            return false;
+//        }
+//    }
+//}

URMPakcage/URMPakcage.csproj

@@ -0,0 +1,41 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>netstandard2.0</TargetFramework>
+		<AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+	</PropertyGroup>
+
+	<ItemGroup>
+	  <PackageReference Include="SkiaSharp" Version="2.88.3" />
+	  <PackageReference Include="System.Buffers" Version="4.4.0" />
+	</ItemGroup>
+	<ItemGroup>
+		<PackageReference Include="System.Memory" Version="4.5.3" />
+		<PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.5.2" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <Reference Include="FrameFirstGen">
+	    <HintPath>libs\FrameFirstGen.dll</HintPath>
+	  </Reference>
+	  <Reference Include="MWArray">
+	    <HintPath>libs\MWArray.dll</HintPath>
+	  </Reference>
+	  <Reference Include="SR_Main">
+	    <HintPath>libs\SR_Main.dll</HintPath>
+	  </Reference>
+	  <Reference Include="Vinno.Core">
+	    <HintPath>libs\Vinno.Core.dll</HintPath>
+	  </Reference>
+	  <Reference Include="Vinno.CoreIn">
+	    <HintPath>libs\Vinno.CoreIn.dll</HintPath>
+	  </Reference>
+	  <Reference Include="Vinno.DataManager">
+	    <HintPath>libs\Vinno.DataManager.dll</HintPath>
+	  </Reference>
+	  <Reference Include="Vinno.Models.Base">
+	    <HintPath>libs\Vinno.Models.Base.dll</HintPath>
+	  </Reference>
+	</ItemGroup>
+
+</Project>

URMPakcage/utils/Logger.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace URMPakcage.utils
+{
+    internal class Logger
+    {
+        // 这个方法模拟错误日志输出
+        public static void WriteLineError(string message)
+        {
+            Console.WriteLine("ERROR: " + message);
+        }
+
+        public static void WriteLineInfo(string message, params object[] args)
+        {
+            Console.WriteLine("Info: " + message);
+        }
+
+        // 这个方法模拟强制输出日志信息
+        public static void ForceWriteLine(object message)
+        {
+            Console.WriteLine(message);
+        }
+    }
+}