Initial Python3 wrappers for Hydra Image Processing library.

src/c/CudaImageProccessing.sln

@@ -10,20 +10,39 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CudaMex", "CudaMex.vcxproj"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CudaImageProcessor", "CudaImageProcessor.vcxproj", "{3E663AF2-4E6F-487B-9072-CCA90C66A822}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CudaPy3DLL", "CudaPy3DLL.vcxproj", "{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}"
+	ProjectSection(ProjectDependencies) = postProject
+		{3E663AF2-4E6F-487B-9072-CCA90C66A822} = {3E663AF2-4E6F-487B-9072-CCA90C66A822}
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
 		Release|x64 = Release|x64
+		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{6698E8EC-49D9-421E-AA87-5BCC6B466347}.Debug|x64.ActiveCfg = Debug|x64
 		{6698E8EC-49D9-421E-AA87-5BCC6B466347}.Debug|x64.Build.0 = Debug|x64
+		{6698E8EC-49D9-421E-AA87-5BCC6B466347}.Debug|x86.ActiveCfg = Debug|x64
 		{6698E8EC-49D9-421E-AA87-5BCC6B466347}.Release|x64.ActiveCfg = Release|x64
 		{6698E8EC-49D9-421E-AA87-5BCC6B466347}.Release|x64.Build.0 = Release|x64
+		{6698E8EC-49D9-421E-AA87-5BCC6B466347}.Release|x86.ActiveCfg = Release|x64
 		{3E663AF2-4E6F-487B-9072-CCA90C66A822}.Debug|x64.ActiveCfg = Debug|x64
 		{3E663AF2-4E6F-487B-9072-CCA90C66A822}.Debug|x64.Build.0 = Debug|x64
+		{3E663AF2-4E6F-487B-9072-CCA90C66A822}.Debug|x86.ActiveCfg = Debug|x64
 		{3E663AF2-4E6F-487B-9072-CCA90C66A822}.Release|x64.ActiveCfg = Release|x64
 		{3E663AF2-4E6F-487B-9072-CCA90C66A822}.Release|x64.Build.0 = Release|x64
+		{3E663AF2-4E6F-487B-9072-CCA90C66A822}.Release|x86.ActiveCfg = Release|x64
+		{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}.Debug|x64.ActiveCfg = Debug|x64
+		{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}.Debug|x64.Build.0 = Debug|x64
+		{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}.Debug|x86.ActiveCfg = Debug|Win32
+		{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}.Debug|x86.Build.0 = Debug|Win32
+		{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}.Release|x64.ActiveCfg = Release|x64
+		{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}.Release|x64.Build.0 = Release|x64
+		{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}.Release|x86.ActiveCfg = Release|Win32
+		{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}.Release|x86.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

src/c/CudaMex.vcxproj

@@ -92,10 +92,11 @@ copy $(OutDir)CudaMex.dll "$(ProjectDir)Mex.mexw64"</Command>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="Cuda\Vec.h" />
-    <ClInclude Include="Mex\CommandList.h" />
     <ClInclude Include="Mex\MexCommand.h" />
+    <ClInclude Include="Mex\MexWrapDef.h" />
     <ClInclude Include="Mex\MexKernel.h" />
     <ClInclude Include="Mex\ScopedProcessMutex.h" />
+    <ClInclude Include="WrapCmds\CommandList.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Mex\CudaMex.cpp" />

src/c/CudaMex.vcxproj.filters

@@ -21,15 +21,18 @@
     <ClInclude Include="Mex\MexCommand.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Mex\CommandList.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Mex\ScopedProcessMutex.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="Mex\MexKernel.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="WrapCmds\CommandList.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Mex\MexWrapDef.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Mex\CudaMex.cpp">

src/c/CudaPy3DLL.vcxproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Python\hip_module.cpp" />
+    <ClCompile Include="Python\PyKernel.cpp" />
+    <ClCompile Include="Python\PyWrapClosure.cpp" />
+    <ClCompile Include="Python\PyWrapCommand.cpp" />
+    <ClCompile Include="Python\PyWrapDeviceCount.cpp" />
+    <ClCompile Include="Python\PyWrapDeviceStats.cpp" />
+    <ClCompile Include="Python\PyWrapElementWiseDifference.cpp" />
+    <ClCompile Include="Python\PyWrapEntropyFilter.cpp" />
+    <ClCompile Include="Python\PyWrapGaussian.cpp" />
+    <ClCompile Include="Python\PyWrapGetMinMax.cpp" />
+    <ClCompile Include="Python\PyWrapHighPassFilter.cpp" />
+    <ClCompile Include="Python\PyWrapLoG.cpp" />
+    <ClCompile Include="Python\PyWrapMaxFilter.cpp" />
+    <ClCompile Include="Python\PyWrapMeanFilter.cpp" />
+    <ClCompile Include="Python\PyWrapMedianFilter.cpp" />
+    <ClCompile Include="Python\PyWrapMinFilter.cpp" />
+    <ClCompile Include="Python\PyWrapMinMax.cpp" />
+    <ClCompile Include="Python\PyWrapMultiplySum.cpp" />
+    <ClCompile Include="Python\PyWrapOpener.cpp" />
+    <ClCompile Include="Python\PyWrapStdFilter.cpp" />
+    <ClCompile Include="Python\PyWrapSum.cpp" />
+    <ClCompile Include="Python\PyWrapVarFilter.cpp" />
+    <ClCompile Include="Python\PyWrapWienerFilter.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Python\PyIncludes.h" />
+    <ClInclude Include="Python\PyKernel.h" />
+    <ClInclude Include="Python\PyWrapCommand.h" />
+    <ClInclude Include="Python\PyWrapDef.h" />
+    <ClInclude Include="WrapCmds\CommandList.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>CudaPy3DLL</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)..\Python\</OutDir>
+    <IntDir>$(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName>HIP</TargetName>
+    <TargetExt>.pyd</TargetExt>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)..\Python\</OutDir>
+    <IntDir>$(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName>HIP</TargetName>
+    <TargetExt>.pyd</TargetExt>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(SolutionDir)..\Python\</OutDir>
+    <IntDir>$(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName>HIP</TargetName>
+    <TargetExt>.pyd</TargetExt>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(SolutionDir)..\Python\</OutDir>
+    <IntDir>$(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName>HIP</TargetName>
+    <TargetExt>.pyd</TargetExt>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessToFile>false</PreprocessToFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>CudaImageProcessor_d.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessToFile>false</PreprocessToFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>CudaImageProcessor_d.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessToFile>false</PreprocessToFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>CudaImageProcessor.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessToFile>false</PreprocessToFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>CudaImageProcessor.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file

src/c/CudaPy3DLL.vcxproj.filters

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Python\hip_module.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapCommand.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapDeviceCount.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapDeviceStats.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapClosure.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyKernel.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapElementWiseDifference.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapEntropyFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapGaussian.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapGetMinMax.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapHighPassFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapLoG.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapMaxFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapMeanFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapMedianFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapMinFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapMinMax.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapOpener.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapStdFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapSum.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapVarFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapWienerFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Python\PyWrapMultiplySum.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="WrapCmds\CommandList.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Python\PyWrapDef.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Python\PyWrapCommand.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Python\PyKernel.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Python\PyIncludes.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>
\ No newline at end of file

src/c/Mex/MexCommand.cpp

 #include "MexCommand.h"
 
 #define INSTANCE_COMMANDS
-#include "CommandList.h"
+#include "MexWrapDef.h"
+#include "../WrapCmds/CommandList.h"
 #undef INSTANCE_COMMANDS
 
 #define BUILD_COMMANDS
-#include "CommandList.h"
+#include "MexWrapDef.h"
+#include "../WrapCmds/CommandList.h"
 #undef BUILD_COMMANDS
 
 // Module name info

src/c/Mex/MexCommand.h

@@ -286,4 +286,5 @@ private:
 };
 
 
-#include "CommandList.h"
+#include "MexWrapDef.h"
+#include "../WrapCmds/CommandList.h"

src/c/Mex/MexGetMinMax.cpp

@@ -7,6 +7,7 @@
 
 void MexGetMinMax::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) const
 {
+	// TODO: Why is this the only device with a 0 default?
 	int device = 0;
 
 	if (!mxIsEmpty(prhs[1]))

src/c/Mex/MexLoG.cpp

@@ -109,6 +109,7 @@ void MexLoG::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
 		setupInputPointers(prhs[0], imageDims, &imageInPtr);
 		setupOutputPointers(&plhs[0], imageDims, &imageOutPtr);
 
+		// TODO: Do we really want to use float outputs here?
 		ImageContainer<double> imageIn(imageInPtr, imageDims);
 		ImageContainer<float> imageOut(imageOutPtr, imageDims);
 

src/c/Mex/MexVarFilter.cpp

@@ -33,7 +33,7 @@ void MexVarFilter::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* p
 		ImageContainer<bool> imageIn(imageInPtr, imageDims);
 		ImageContainer<bool> imageOut(imageOutPtr, imageDims);
 
-		stdFilter(imageIn, imageOut, kernel, numIterations, device);
+		varFilter(imageIn, imageOut, kernel, numIterations, device);
 
 	}
 	else if (mxIsUint8(prhs[0]))
@@ -44,7 +44,7 @@ void MexVarFilter::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* p
 		ImageContainer<unsigned char> imageIn(imageInPtr, imageDims);
 		ImageContainer<unsigned char> imageOut(imageOutPtr, imageDims);
 
-		stdFilter(imageIn, imageOut, kernel, numIterations, device);
+		varFilter(imageIn, imageOut, kernel, numIterations, device);
 	}
 	else if (mxIsUint16(prhs[0]))
 	{
@@ -54,7 +54,7 @@ void MexVarFilter::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* p
 		ImageContainer<unsigned short> imageIn(imageInPtr, imageDims);
 		ImageContainer<unsigned short> imageOut(imageOutPtr, imageDims);
 
-		stdFilter(imageIn, imageOut, kernel, numIterations, device);
+		varFilter(imageIn, imageOut, kernel, numIterations, device);
 	}
 	else if (mxIsInt16(prhs[0]))
 	{
@@ -64,7 +64,7 @@ void MexVarFilter::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* p
 		ImageContainer<short> imageIn(imageInPtr, imageDims);
 		ImageContainer<short> imageOut(imageOutPtr, imageDims);
 
-		stdFilter(imageIn, imageOut, kernel, numIterations, device);
+		varFilter(imageIn, imageOut, kernel, numIterations, device);
 	}
 	else if (mxIsUint32(prhs[0]))
 	{
@@ -74,7 +74,7 @@ void MexVarFilter::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* p
 		ImageContainer<unsigned int> imageIn(imageInPtr, imageDims);
 		ImageContainer<unsigned int> imageOut(imageOutPtr, imageDims);
 
-		stdFilter(imageIn, imageOut, kernel, numIterations, device);
+		varFilter(imageIn, imageOut, kernel, numIterations, device);
 	}
 	else if (mxIsInt32(prhs[0]))
 	{
@@ -84,7 +84,7 @@ void MexVarFilter::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* p
 		ImageContainer<int> imageIn(imageInPtr, imageDims);
 		ImageContainer<int> imageOut(imageOutPtr, imageDims);
 
-		stdFilter(imageIn, imageOut, kernel, numIterations, device);
+		varFilter(imageIn, imageOut, kernel, numIterations, device);
 	}
 	else if (mxIsSingle(prhs[0]))
 	{
@@ -94,7 +94,7 @@ void MexVarFilter::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* p
 		ImageContainer<float> imageIn(imageInPtr, imageDims);
 		ImageContainer<float> imageOut(imageOutPtr, imageDims);
 
-		stdFilter(imageIn, imageOut, kernel, numIterations, device);
+		varFilter(imageIn, imageOut, kernel, numIterations, device);
 	}
 	else if (mxIsDouble(prhs[0]))
 	{
@@ -104,7 +104,7 @@ void MexVarFilter::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* p
 		ImageContainer<double> imageIn(imageInPtr, imageDims);
 		ImageContainer<double> imageOut(imageOutPtr, imageDims);
 
-		stdFilter(imageIn, imageOut, kernel, numIterations, device);
+		varFilter(imageIn, imageOut, kernel, numIterations, device);
 	}
 	else
 	{

src/c/Mex/CommandList.h → src/c/Mex/MexWrapDef.h

-#undef DEF_MEX_COMMAND
-#undef BEGIN_MEX_COMMANDS
-#undef END_MEX_COMMANDS
+#undef BEGIN_WRAP_COMMANDS
+#undef END_WRAP_COMMANDS
+#undef DEF_WRAP_COMMAND
 
 #if defined(INSTANCE_COMMANDS)
-#define BEGIN_MEX_COMMANDS
-#define END_MEX_COMMANDS
-#define DEF_MEX_COMMAND(name) Mex##name _ginstMex##name;
+#define BEGIN_WRAP_COMMANDS
+#define END_WRAP_COMMANDS
+#define DEF_WRAP_COMMAND(name) Mex##name _ginstMex##name;
 #elif defined(BUILD_COMMANDS)
-#define BEGIN_MEX_COMMANDS																								\
-	MexCommand* const MexCommand::m_commands[] =												\
+#define BEGIN_WRAP_COMMANDS																								\
+	MexCommand* const MexCommand::m_commands[] =																		\
 							{
 
-#define END_MEX_COMMANDS																								\
+#define END_WRAP_COMMANDS																								\
 							};																							\
 							const size_t MexCommand::m_numCommands = sizeof(MexCommand::m_commands) / sizeof(MexCommand*);
 
-#define DEF_MEX_COMMAND(name) &_ginstMex##name,
+#define DEF_WRAP_COMMAND(name) &_ginstMex##name,
 #else
-#define BEGIN_MEX_COMMANDS
-#define END_MEX_COMMANDS
-#define DEF_MEX_COMMAND(name)																	\
+#define BEGIN_WRAP_COMMANDS
+#define END_WRAP_COMMANDS
+#define DEF_WRAP_COMMAND(name)																\
 class Mex##name : public MexCommand															\
-	{																									\
-	public:																								\
+{																							\
+	public:																					\
 	virtual std::string check(int nlhs,mxArray* plhs[],int nrhs,const mxArray* prhs[]) const;	\
 	virtual void execute(int nlhs,mxArray* plhs[],int nrhs,const mxArray* prhs[])  const;		\
 	\
 	virtual void usage(std::vector<std::string>& outArgs,std::vector<std::string>& inArgs)  const;	\
 	virtual void help(std::vector<std::string>& helpLines) const;									\
 	\
-	Mex##name() :MexCommand(#name) {};															\
-	};
+	Mex##name() :MexCommand(#name) {};														\
+};
 #endif
-
-BEGIN_MEX_COMMANDS
-// These are default commands defined for all MEX routines.
-DEF_MEX_COMMAND(Info)
-DEF_MEX_COMMAND(Help)
-// Additional specific mex commands should be added here.
-DEF_MEX_COMMAND(DeviceCount)
-DEF_MEX_COMMAND(DeviceStats)
-DEF_MEX_COMMAND(Closure)
-DEF_MEX_COMMAND(ElementWiseDifference)
-DEF_MEX_COMMAND(EntropyFilter)
-DEF_MEX_COMMAND(Gaussian)
-DEF_MEX_COMMAND(GetMinMax)
-DEF_MEX_COMMAND(HighPassFilter)
-DEF_MEX_COMMAND(LoG)
-DEF_MEX_COMMAND(MaxFilter)
-DEF_MEX_COMMAND(MeanFilter)
-DEF_MEX_COMMAND(MedianFilter)
-DEF_MEX_COMMAND(MinFilter)
-DEF_MEX_COMMAND(MinMax)
-DEF_MEX_COMMAND(MultiplySum)
-DEF_MEX_COMMAND(Opener)
-DEF_MEX_COMMAND(StdFilter)
-DEF_MEX_COMMAND(Sum)
-DEF_MEX_COMMAND(VarFilter)
-DEF_MEX_COMMAND(WienerFilter)
-END_MEX_COMMANDS

src/c/Python/PyIncludes.h

+#pragma once
+
+#include <Python.h>
+
+// Make sure that Numpy symbols don't get re-imported in multiple compilation units
+#ifndef NUMPY_IMPORT_MODULE
+	#define NO_IMPORT_ARRAY
+#endif
+
+#define PY_ARRAY_UNIQUE_SYMBOL HIP_ARRAY_API
+#include <numpy/arrayobject.h>
+
+#include <py3c.h>

src/c/Python/PyKernel.cpp

+#include "PyKernel.h"
+
+#include "../Cuda/Vec.h"
+#include "../Cuda/ImageDimensions.cuh"
+
+#include <string.h>
+
+
+ImageContainer<float> getKernel(PyArrayObject* kernel)
+{
+	int numDims = PyArray_NDIM(kernel);
+	const npy_intp* DIMS = PyArray_DIMS(kernel);
+
+	Vec<size_t> kernDims(1);
+
+	if ( numDims > 2 )
+		kernDims.z = (size_t)DIMS[2];
+	else
+		kernDims.z = 1;
+
+	if ( numDims > 1 )
+		kernDims.y = (size_t)DIMS[1];
+	else
+		kernDims.y = 1;
+
+	if ( numDims > 0 )
+		kernDims.x = (size_t)DIMS[0];
+	else
+		return ImageContainer<float>();
+
+	ImageContainer<float> kernelOut;
+	kernelOut.resize(ImageDimensions(kernDims, 1, 1));
+
+	float* kernPtr = kernelOut.getPtr();
+
+	
+	if ( PyArray_TYPE(kernel) == NPY_BOOL )
+	{
+		bool* mexKernelData;
+		mexKernelData = (bool*)PyArray_DATA(kernel);
+
+		for ( int i = 0; i < kernDims.product(); ++i )
+		{
+			if ( mexKernelData[i] )
+				kernPtr[i] = 1.0f;
+			else
+				kernPtr[i] = 0.0f;
+		}
+	}
+	else if ( PyArray_TYPE(kernel) == NPY_UINT8 )
+	{
+		unsigned char* mexKernelData;
+		mexKernelData = (unsigned char*)PyArray_DATA(kernel);
+
+		for ( int i = 0; i < kernDims.product(); ++i )
+		{
+			double val = mexKernelData[i];
+			kernPtr[i] = (float)val;
+		}
+	}
+	else if ( PyArray_TYPE(kernel) == NPY_INT16 )
+	{
+		short* mexKernelData;
+		mexKernelData = (short*)PyArray_DATA(kernel);
+
+		for ( int i = 0; i < kernDims.product(); ++i )
+		{
+			short val = mexKernelData[i];
+			kernPtr[i] = (float)val;
+		}
+	}
+	else if ( PyArray_TYPE(kernel) == NPY_UINT16 )
+	{
+		unsigned short* mexKernelData;
+		mexKernelData = (unsigned short*)PyArray_DATA(kernel);
+
+		for ( int i = 0; i < kernDims.product(); ++i )
+		{
+			unsigned short val = mexKernelData[i];
+			kernPtr[i] = (float)val;
+		}
+	}
+	else if ( PyArray_TYPE(kernel) == NPY_INT32 )
+	{
+		int* mexKernelData;
+		mexKernelData = (int*)PyArray_DATA(kernel);
+
+		for ( int i = 0; i < kernDims.product(); ++i )
+		{
+			int val = mexKernelData[i];
+			kernPtr[i] = (float)val;
+		}
+	}
+	else if ( PyArray_TYPE(kernel) == NPY_UINT32 )
+	{
+		unsigned int* mexKernelData;
+		mexKernelData = (unsigned int*)PyArray_DATA(kernel);
+
+		for ( int i = 0; i < kernDims.product(); ++i )
+		{
+			unsigned int val = mexKernelData[i];
+			kernPtr[i] = (float)val;
+		}
+	}
+	else if ( PyArray_TYPE(kernel) == NPY_FLOAT )
+	{
+		float* mexKernelData = (float*)PyArray_DATA(kernel);
+		memcpy(kernPtr, mexKernelData, sizeof(float)*kernDims.product());
+	}
+	else if ( PyArray_TYPE(kernel) == NPY_DOUBLE )
+	{
+		double* mexKernelData;
+		mexKernelData = (double*)PyArray_DATA(kernel);
+
+		for ( int i = 0; i < kernDims.product(); ++i )
+		{
+			double val = mexKernelData[i];
+			kernPtr[i] = (float)val;
+		}
+	}
+
+	return kernelOut;
+}

src/c/Python/PyKernel.h

+#pragma once
+
+#include "../Cuda/ImageContainer.h"
+#include "../Cuda/Vec.h"
+
+#include "PyIncludes.h"
+
+ImageContainer<float> getKernel(PyArrayObject* kernel);

src/c/Python/PyWrapClosure.cpp

+#include "PyWrapCommand.h"
+
+#include "../Cuda/Vec.h"
+#include "../Cuda/CWrappers.h"
+#include "../Cuda/ImageDimensions.cuh"
+#include "../Cuda/ImageContainer.h"
+
+#include "PyKernel.h"
+
+
+const char PyWrapClosure::docString[] = "imageOut = HIP.Closure(imageIn,kernel,[numIterations],[device])\n\n"\
+"This kernel will dilate followed by an erosion.\n"\
+"\timageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.\n"\
+"\t\tThe spatial dimensions will have the kernel applied. The last two dimensions will determine\n"\
+"\t\thow to stride or jump to the next spatial block.\n"\
+"\n"\
+"\tkernel = This is a one to three dimensional array that will be used to determine neighborhood operations.\n"\
+"\t\tIn this case, the positions in the kernel that do not equal zeros will be evaluated.\n"\
+"\t\tIn other words, this can be viewed as a structuring element for the max neighborhood.\n"\
+"\n"\
+"\tnumIterations (optional) =  This is the number of iterations to run the max filter for a given position.\n"\
+"\t\tThis is useful for growing regions by the shape of the structuring element or for very large neighborhoods.\n"\
+"\t\tCan be empty an array [].\n"\
+"\n"\
+"\tdevice (optional) = Use this if you have multiple devices and want to select one explicitly.\n"\
+"\t\tSetting this to [] allows the algorithm to either pick the best device and/or will try to split\n"\
+"\t\tthe data across multiple devices.\n"\
+"\n"\
+"\timageOut = This will be an array of the same type and shape as the input array.\n";
+
+
+PyObject* PyWrapClosure::execute(PyObject* self, PyObject* args)
+{
+	PyObject* imIn;
+	PyObject* inKern;
+
+	int numIterations = 1;
+	int device = -1;
+
+	if ( !PyArg_ParseTuple(args, "O!O!|ii", &PyArray_Type, &imIn, &PyArray_Type, &inKern,
+						&numIterations, &device) )
+		return nullptr;
+
+	if ( imIn == nullptr ) return nullptr;
+	if ( inKern == nullptr ) return nullptr;
+
+	PyArrayObject* kernContig = (PyArrayObject*) PyArray_FROM_OTF(inKern, NPY_NOTYPE, NPY_ARRAY_IN_ARRAY);
+	PyArrayObject* imContig = (PyArrayObject*) PyArray_FROM_OTF(imIn, NPY_NOTYPE, NPY_ARRAY_IN_ARRAY);
+
+	ImageContainer<float> kernel = getKernel(kernContig);
+	Py_XDECREF(kernContig);
+
+	if ( kernel.getDims().getNumElements() == 0 )
+	{
+		kernel.clear();
+
+		PyErr_SetString(PyExc_RuntimeError, "Unable to create kernel");
+		return nullptr;
+	}
+
+	ImageDimensions imageDims;
+	PyArrayObject* imOut = nullptr;
+
+	if ( PyArray_TYPE(imContig) == NPY_BOOL )
+	{
+		bool* imageInPtr, *imageOutPtr;
+		setupImagePointers(imContig, &imageInPtr, imageDims, &imOut, &imageOutPtr);
+
+		ImageContainer<bool> imageIn(imageInPtr, imageDims);
+		ImageContainer<bool> imageOut(imageOutPtr, imageDims);
+
+		closure(imageIn, imageOut, kernel, numIterations, device);
+
+	}
+	else if ( PyArray_TYPE(imContig) == NPY_UINT8 )
+	{
+		unsigned char* imageInPtr, *imageOutPtr;
+		setupImagePointers(imContig, &imageInPtr, imageDims, &imOut, &imageOutPtr);
+
+		ImageContainer<unsigned char> imageIn(imageInPtr, imageDims);
+		ImageContainer<unsigned char> imageOut(imageOutPtr, imageDims);
+
+		closure(imageIn, imageOut, kernel, numIterations, device);
+	}
+	else if ( PyArray_TYPE(imContig) == NPY_UINT16 )
+	{
+		unsigned short* imageInPtr, *imageOutPtr;
+		setupImagePointers(imContig, &imageInPtr, imageDims, &imOut, &imageOutPtr);
+
+		ImageContainer<unsigned short> imageIn(imageInPtr, imageDims);
+		ImageContainer<unsigned short> imageOut(imageOutPtr, imageDims);
+
+		closure(imageIn, imageOut, kernel, numIterations, device);
+	}
+	else if ( PyArray_TYPE(imContig) == NPY_INT16 )
+	{
+		short* imageInPtr, *imageOutPtr;
+		setupImagePointers(imContig, &imageInPtr, imageDims, &imOut, &imageOutPtr);
+
+		ImageContainer<short> imageIn(imageInPtr, imageDims);
+		ImageContainer<short> imageOut(imageOutPtr, imageDims);
+
+		closure(imageIn, imageOut, kernel, numIterations, device);
+	}
+	else if ( PyArray_TYPE(imContig) == NPY_UINT32 )
+	{
+		unsigned int* imageInPtr, *imageOutPtr;
+		setupImagePointers(imContig, &imageInPtr, imageDims, &imOut, &imageOutPtr);
+
+		ImageContainer<unsigned int> imageIn(imageInPtr, imageDims);
+		ImageContainer<unsigned int> imageOut(imageOutPtr, imageDims);
+
+		closure(imageIn, imageOut, kernel, numIterations, device);
+	}
+	else if ( PyArray_TYPE(imContig) == NPY_INT32 )
+	{
+		int* imageInPtr, *imageOutPtr;
+		setupImagePointers(imContig, &imageInPtr, imageDims, &imOut, &imageOutPtr);
+
+		ImageContainer<int> imageIn(imageInPtr, imageDims);
+		ImageContainer<int> imageOut(imageOutPtr, imageDims);
+
+		closure(imageIn, imageOut, kernel, numIterations, device);
+	}
+	else if ( PyArray_TYPE(imContig) == NPY_FLOAT )
+	{
+		float* imageInPtr, *imageOutPtr;
+		setupImagePointers(imContig, &imageInPtr, imageDims, &imOut, &imageOutPtr);
+
+		ImageContainer<float> imageIn(imageInPtr, imageDims);
+		ImageContainer<float> imageOut(imageOutPtr, imageDims);
+
+		closure(imageIn, imageOut, kernel, numIterations, device);
+	}
+	else if ( PyArray_TYPE(imContig) == NPY_DOUBLE )
+	{
+		double* imageInPtr, *imageOutPtr;
+		setupImagePointers(imContig, &imageInPtr, imageDims, &imOut, &imageOutPtr);
+
+		ImageContainer<double> imageIn(imageInPtr, imageDims);
+		ImageContainer<double> imageOut(imageOutPtr, imageDims);
+
+		closure(imageIn, imageOut, kernel, numIterations, device);
+	}
+	else
+	{
+		PyErr_SetString(PyExc_RuntimeError, "Image type not supported.");
+
+		Py_XDECREF(imContig);
+		Py_XDECREF(imOut);
+
+		return nullptr;
+	}
+
+	Py_XDECREF(imContig);
+
+	kernel.clear();
+
+	return ((PyObject*)imOut);
+}

src/c/Python/PyWrapCommand.cpp

+// Setup for defining wrapped commands
+#include "PyWrapCommand.h"
+
+#define INSTANCE_COMMANDS
+#include "PyWrapDef.h"
+#include "../WrapCmds/CommandList.h"
+#undef INSTANCE_COMMANDS
+
+#define BUILD_COMMANDS
+#include "PyWrapDef.h"
+#include "../WrapCmds/CommandList.h"
+#undef BUILD_COMMANDS
+
+
+void setupDims(PyArrayObject* im, ImageDimensions& dimsOut)
+{
+	dimsOut.dims = Vec<size_t>(1);
+	dimsOut.chan = 1;
+	dimsOut.frame = 1;
+
+	int numDims = PyArray_NDIM(im);
+	const npy_intp* DIMS = PyArray_DIMS(im);
+
+	for ( int i=0; i < std::min(numDims, 3); ++i )
+		dimsOut.dims.e[i] = (size_t)DIMS[i];
+
+	if ( numDims > 3 )
+		dimsOut.chan = (unsigned int)DIMS[3];
+
+	if ( numDims > 4 )
+		dimsOut.frame = (unsigned int)DIMS[4];
+}
+
+
+template <typename T, typename U>
+void converter(void* in, void* out, size_t len)
+{
+	for ( int i=0; i < len; ++i )
+		((U*)out)[i] = static_cast<U>(((T*)in)[i]);
+}
+
+bool pyarrayToVec(PyObject* ar, Vec<double>& outVec)
+{
+	int ndim = PyArray_NDIM(ar);
+	if ( ndim > 1 )
+		return false;
+
+	int array_size = PyArray_DIM(ar, 0);
+	if ( array_size != 3 )
+		return false;
+
+	if ( PyArray_TYPE(ar) == NPY_UINT8 )
+		converter<uint8_t,double>(PyArray_DATA(ar), outVec.e, array_size);
+	else if ( PyArray_TYPE(ar) == NPY_UINT16 )
+		converter<uint16_t, double>(PyArray_DATA(ar), outVec.e, array_size);
+	else if ( PyArray_TYPE(ar) == NPY_INT16 )
+		converter<int16_t, double>(PyArray_DATA(ar), outVec.e, array_size);
+	else if ( PyArray_TYPE(ar) == NPY_UINT32 )
+		converter<uint32_t, double>(PyArray_DATA(ar), outVec.e, array_size);
+	else if ( PyArray_TYPE(ar) == NPY_INT32 )
+		converter<int32_t, double>(PyArray_DATA(ar), outVec.e, array_size);
+	else if ( PyArray_TYPE(ar) == NPY_FLOAT )
+		converter<float, double>(PyArray_DATA(ar), outVec.e, array_size);
+	else if ( PyArray_TYPE(ar) == NPY_DOUBLE )
+		converter<double, double>(PyArray_DATA(ar), outVec.e, array_size);
+
+	return true;
+}
+
+
+bool pylistToVec(PyObject* list, Vec<double>& outVec)
+{
+	Py_ssize_t list_size = PyList_Size(list);
+	if ( list_size != 3 )
+		return false;
+
+	for ( int i=0; i < list_size; ++i )
+	{
+		PyObject* item = PyList_GetItem(list, i);
+		if ( PyLong_Check(item) )
+			outVec.e[i] = PyLong_AsDouble(item);
+		else if ( PyFloat_Check(item) )
+			outVec.e[i] = PyFloat_AsDouble(item);
+		else
+			return false;
+	}
+
+	return true;
+}
+
+
+bool pyobjToVec(PyObject* list_array, Vec<double>& outVec)
+{
+	if ( PyList_Check(list_array) )
+		return pylistToVec(list_array, outVec);
+
+	else if ( PyArray_Check(list_array) )
+		return pyarrayToVec(list_array, outVec);
+
+	return false;
+}
+
+
+// Info Command (unimplemented)
+const char PyWrapInfo::docString[] = "Not implemented for Python bindings.";
+PyObject* PyWrapInfo::execute(PyObject* self, PyObject* args)
+{
+	PyErr_SetString(PyExc_RuntimeWarning, "Info() not implemented for Python!");
+	return nullptr;
+}
+
+// Help Command (unimplemented)
+const char PyWrapHelp::docString[] = "Not implemented for Python bindings.";
+PyObject* PyWrapHelp::execute(PyObject* self, PyObject* args)
+{
+	PyErr_SetString(PyExc_RuntimeWarning, "Help() not implemented for Python!");
+	return nullptr;
+}
\ No newline at end of file

src/c/Python/PyWrapCommand.h

+#pragma once
+#include <string>
+#include <algorithm>
+
+#include "../Cuda/Vec.h"
+#include "../Cuda/ImageDimensions.cuh"
+
+#include "PyIncludes.h"
+
+
+// Simple template-specialization map for C++ to mex types
+template <typename T> struct TypeMap { static const NPY_TYPES npyType; };
+template <> struct TypeMap<bool> { static const NPY_TYPES npyType = NPY_BOOL; };
+template <> struct TypeMap<char> { static const NPY_TYPES npyType = NPY_INT8; };
+template <> struct TypeMap<short> { static const NPY_TYPES npyType = NPY_INT16; };
+template <> struct TypeMap<int> { static const NPY_TYPES npyType = NPY_INT32; };
+template <> struct TypeMap<unsigned char> { static const NPY_TYPES npyType = NPY_UINT8; };
+template <> struct TypeMap<unsigned short> { static const NPY_TYPES npyType = NPY_UINT16; };
+template <> struct TypeMap<unsigned int> { static const NPY_TYPES npyType = NPY_UINT32; };
+template <> struct TypeMap<float> { static const NPY_TYPES npyType = NPY_FLOAT; };
+template <> struct TypeMap<double> { static const NPY_TYPES npyType = NPY_DOUBLE; };
+
+
+void setupDims(PyArrayObject* im, ImageDimensions& dimsOut);
+bool pyobjToVec(PyObject* list_array, Vec<double>& outVec);
+
+// General array creation method
+template <typename T>
+PyArrayObject* createArray(int ndim, npy_intp* dims)
+{
+	return ((PyArrayObject*)PyArray_SimpleNew(ndim, dims, TypeMap<T>::npyType));
+}
+
+template <typename T>
+void setupImagePointers(PyArrayObject* imageIn, T** image, ImageDimensions& dims, PyArrayObject** argOut = nullptr, T** imageOut = nullptr)
+{
+	setupInputPointers(imageIn, dims, image);
+	if ( argOut != nullptr && imageOut != nullptr )
+		setupOutputPointers(argOut, dims, imageOut);
+}
+
+template <typename T>
+void setupInputPointers(PyArrayObject* imageIn, ImageDimensions& dims, T** image)
+{
+	setupDims(imageIn, dims);
+	*image = (T*)PyArray_DATA(imageIn);
+}
+
+template <typename T>
+void setupOutputPointers(PyArrayObject** imageOut, ImageDimensions& dims, T** image)
+{
+	npy_intp pyDims[5];
+	for ( int i = 0; i < 3; ++i )
+		pyDims[i] = dims.dims.e[i];
+
+	pyDims[3] = dims.chan;
+	pyDims[4] = dims.frame;
+
+	*imageOut = createArray<T>(5, pyDims);
+	*image = (T*)PyArray_DATA(*imageOut);
+
+	memset(*image, 0, sizeof(T)*dims.getNumElements());
+}
+
+
+#include "PyWrapDef.h"
+#include "../WrapCmds/CommandList.h"

src/c/Python/PyWrapDef.h

+#undef BEGIN_WRAP_COMMANDS
+#undef END_WRAP_COMMANDS
+#undef DEF_WRAP_COMMAND
+
+#if defined(INSTANCE_COMMANDS)
+#define BEGIN_WRAP_COMMANDS
+#define END_WRAP_COMMANDS
+#define DEF_WRAP_COMMAND(name)
+#elif defined(BUILD_COMMANDS)
+#define BEGIN_WRAP_COMMANDS						\
+	struct PyMethodDef hip_methods[] =			\
+	{
+
+#define END_WRAP_COMMANDS						\
+		{nullptr, nullptr, 0, nullptr}			\
+	};
+
+#define DEF_WRAP_COMMAND(name) {#name, PyWrap##name::execute, METH_VARARGS, PyWrap##name::docString},
+#else
+#define BEGIN_WRAP_COMMANDS
+#define END_WRAP_COMMANDS
+#define DEF_WRAP_COMMAND(name)									\
+class PyWrap##name												\
+{																\
+public:															\
+	static PyObject* execute(PyObject* self, PyObject* args);	\
+	static const char docString[];								\
+};
+#endif

src/c/Python/PyWrapDeviceCount.cpp

+#include "PyWrapCommand.h"
+#include "../Cuda/CWrappers.h"
+
+
+const char PyWrapDeviceCount::docString[] = "NumCudaDevices, MemoryStats = HIP.DeviceCount()\n\n"\
+	"This will return the number of Cuda devices available, and their memory.\n"\
+	"\tNumCudaDevices -- this is the number of Cuda devices available.\n"\
+	"\tMemoryStats -- this is an array of structures where each entry corresponds to a Cuda device.\n"\
+	"The memory structure contains the total memory on the device and the memory available for a Cuda call.\n";
+
+PyObject* PyWrapDeviceCount::execute(PyObject* self, PyObject* args)
+{
+	if ( !PyArg_ParseTuple(args, "") )
+		return nullptr;
+
+	size_t* memStats;
+	int numDevices = memoryStats(&memStats);
+
+	PyObject* py_mem = PyList_New(numDevices);
+	for ( int i=0; i < numDevices; ++i )
+	{
+		PyObject* py_struct = Py_BuildValue("{sksk}", "total", memStats[i*2], "available", memStats[i*2+1]);
+		PyList_SetItem(py_mem, i, py_struct);
+	}
+
+	return Py_BuildValue("(kN)", numDevices, py_mem);
+}

src/c/Python/PyWrapDeviceStats.cpp

+#include "PyWrapCommand.h"
+
+#include "../Cuda/CWrappers.h"
+#include "../Cuda/CudaDeviceStats.h"
+
+
+const char PyWrapDeviceStats::docString[] = "DeviceStatsArray = HIP.DeviceStats()\n\n"\
+	"This will return the statistics of each Cuda capable device installed.\n"\
+	"\tDeviceStatsArray -- this is an array of structs, one struct per device.\n"\
+	"The struct has these fields: name, major, minor, constMem, sharedMem, totalMem, tccDriver, mpCount, threadsPerMP, warpSize, maxThreads.\n";
+
+
+PyObject* PyWrapDeviceStats::execute(PyObject* self, PyObject* args)
+{
+	if ( !PyArg_ParseTuple(args, "") )
+		return nullptr;
+
+	DevStats* devStats;
+	int numDevices = deviceStats(&devStats);
+
+	PyObject* py_stats = PyList_New(numDevices);
+	for ( int device = 0; device<numDevices; ++device )
+	{
+		DevStats& dev = devStats[device];
+
+		PyObject* dict = PyDict_New();
+		PyDict_SetItemString(dict, "name", PyStr_FromString(dev.name.c_str()));
+		PyDict_SetItemString(dict, "major", PyLong_FromLong(dev.major));
+		PyDict_SetItemString(dict, "minor", PyLong_FromLong(dev.minor));
+		PyDict_SetItemString(dict, "constMem", PyLong_FromUnsignedLongLong(dev.constMem));
+		PyDict_SetItemString(dict, "sharedMem", PyLong_FromUnsignedLongLong(dev.sharedMem));
+		PyDict_SetItemString(dict, "totalMem", PyLong_FromUnsignedLongLong(dev.totalMem));
+		PyDict_SetItemString(dict, "tccDriver", PyBool_FromLong(dev.tccDriver));
+		PyDict_SetItemString(dict, "mpCount", PyLong_FromLong(dev.mpCount));
+		PyDict_SetItemString(dict, "threadsPerMP", PyLong_FromLong(dev.threadsPerMP));
+		PyDict_SetItemString(dict, "warpSize", PyLong_FromLong(dev.warpSize));
+		PyDict_SetItemString(dict, "maxThreads", PyLong_FromLong(dev.maxThreads));
+
+		PyList_SetItem(py_stats, device, dict);
+	}
+
+	delete[] devStats;
+
+	return py_stats;
+}