bool ToFCameraPMDController::GetDistances(float* distanceArray)
{
float* tempArray = new float[m_CaptureWidth*m_CaptureHeight];
this->m_PMDRes = pmdGetDistances(m_PMDHandle, tempArray, this->m_NumberOfBytes);
TransformCameraOutput(tempArray, distanceArray, true);
delete[] tempArray;
return ErrorText(this->m_PMDRes);
}
bool mitk::ToFCameraPMDCamBoardController::SetFieldOfView( float fov )
{
//return true;
std::stringstream commandStream;
commandStream<<"SetFOV "<<fov;
this->m_PMDRes = pmdProcessingCommand(m_PMDHandle, 0, 0, commandStream.str().c_str());
return ErrorText(this->m_PMDRes);
}
int ToFCameraPMDController::SetIntegrationTime(unsigned int integrationTime)
{
if(!m_ConnectionCheck)
{
return integrationTime;
}
unsigned int result;
this->m_PMDRes = pmdGetValidIntegrationTime(m_PMDHandle, &result, 0, CloseTo, integrationTime);
MITK_INFO << "Valid Integration Time = " << result;
ErrorText(this->m_PMDRes);
if (this->m_PMDRes != 0)
{
return 0;
}
this->m_PMDRes = pmdSetIntegrationTime(m_PMDHandle, 0, result);
ErrorText(this->m_PMDRes);
return result;
}
int ToFCameraPMDController::SetModulationFrequency(unsigned int modulationFrequency)
{
if(!m_ConnectionCheck)
{
return modulationFrequency;
}
unsigned int result;
this->m_PMDRes = pmdGetValidModulationFrequency(m_PMDHandle, &result, 0, AtLeast, (modulationFrequency*1000000));
MITK_INFO << "Valid Modulation Frequency = " << result;
ErrorText(this->m_PMDRes);
if (this->m_PMDRes != 0)
{
return 0;
}
this->m_PMDRes = pmdSetModulationFrequency(m_PMDHandle, 0, result);
ErrorText(this->m_PMDRes);
return (result/1000000);;
}
bool mitk::ToFCameraPMDCamBoardController::SetExposureMode( int mode )
{
if (mode==0) // normal mode
{
this->m_PMDRes = pmdSourceCommand(m_PMDHandle, 0, 0, "SetExposureMode Normal");
return ErrorText(this->m_PMDRes);
}
else if (mode==1) // SMB mode
{
this->m_PMDRes = pmdSourceCommand(m_PMDHandle, 0, 0, "SetExposureMode SMB");
return ErrorText(this->m_PMDRes);
}
else
{
MITK_ERROR<<"Specified exposure mode not supported. Exposure mode must be 0 (Normal) or 1 (SMB)";
return false;
}
}
void WinFileStream::setEof(uint64_t newSize)
{
assert(INVALID_HANDLE_VALUE != m_hFile);
uint64_t oldPos = do_seek(newSize, FILE_BEGIN);
BOOL bRet = SetEndOfFile(m_hFile);
seek(oldPos, FILE_BEGIN);
if (!bRet)
throw IOException(ErrorText(GetLastError()).c_str());
}
size_t WinFileStream::read(void* vbuf, size_t length)
{
assert(INVALID_HANDLE_VALUE != m_hFile);
DWORD nReaded;
if (ReadFile(m_hFile, vbuf, length, &nReaded, 0))
{
return nReaded;
}
throw IOException(ErrorText(GetLastError()).c_str());
}
size_t WinFileStream::write(const void* vbuf, size_t length)
{
assert(INVALID_HANDLE_VALUE != m_hFile);
DWORD nWritten;
if (WriteFile(m_hFile, vbuf, length, &nWritten, 0))
{
return nWritten;
}
throw IOException(ErrorText(GetLastError()).c_str());
}
bool ToFCameraPMDMITKPlayerController::CloseCameraConnection()
{
if(m_MitkImage.IsNotNull())
{
this->m_MitkImage->ReleaseData();
}
this->m_PMDRes = pmdClose(m_PMDHandle);
m_ConnectionCheck = ErrorText(this->m_PMDRes);
m_PMDHandle = 0;
return m_ConnectionCheck;
}
WinFileStream::WinFileStream(
LPCSTR szFile,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes)
{
if (!open(szFile, dwDesiredAccess, dwShareMode, lpSecurityAttributes))
{
throw OpenFileException(szFile, ErrorText(GetLastError()).c_str());
}
}
bool mitk::ToFCameraPMDCamBoardController::SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height )
{
// check if leftUpperCornerX and width are divisible by 3 otherwise round to the next value divisible by 3
unsigned int factor = leftUpperCornerX/3;
leftUpperCornerX = 3*factor;
factor = width/3;
width = 3*factor;
std::stringstream command;
command<<"SetROI "<<leftUpperCornerX<<" "<<leftUpperCornerY<<" "<<width<<" "<<height;
this->m_PMDRes = pmdSourceCommand(m_PMDHandle,0,0,command.str().c_str());
return ErrorText(this->m_PMDRes);
}
uint64_t WinFileStream::size()
{
assert(INVALID_HANDLE_VALUE != m_hFile);
uint32_t hi32;
uint32_t lo32 = GetFileSize(m_hFile, &hi32);
DWORD err;
if (INVALID_FILE_SIZE == lo32 && NO_ERROR != (err = GetLastError()))
{
throw IOException(ErrorText(err).c_str());
}
return uint64_t(hi32) << 32 | lo32;
}
uint64_t WinFileStream::do_seek(int64_t offset, int origin)
{
assert(INVALID_HANDLE_VALUE != m_hFile);
LONG hi32 = LONG(uint64_t(offset) >> 32);
LONG lo32 = LONG(offset & 0xFFFFFFFF);
lo32 = SetFilePointer(m_hFile, lo32, &hi32, origin);
DWORD err;
if (INVALID_SET_FILE_POINTER == lo32 && (err = GetLastError()) != NO_ERROR)
{
throw IOException(ErrorText(err).c_str());
}
return uint64_t(hi32) << 32 | lo32;
}
uint64_t WinFileStream::tell() const
{
assert(INVALID_HANDLE_VALUE != m_hFile);
LONG hi32 = 0;
LONG lo32 = 0;
lo32 = SetFilePointer(m_hFile, lo32, &hi32, FILE_CURRENT);
DWORD err;
if (INVALID_SET_FILE_POINTER == lo32 && (err = GetLastError()) != NO_ERROR)
{
throw IOException(ErrorText(err).c_str());
}
return uint64_t(hi32) << 32 | lo32;
}
WinFileStream::WinFileStream(
LPCSTR szFile,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile)
{
if (!open(szFile, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile))
{
throw OpenFileException(szFile, ErrorText(GetLastError()).c_str());
}
}
bool ToFCameraPMDMITKPlayerController::ReadFile()
{
this->m_PMDRes = pmdOpenProcessingPlugin (&m_PMDHandle , this->m_ProcPlugin , this->m_ProcParam );
bool ok = ErrorText(this->m_PMDRes);
if (!ok)
{
return false;
}
ok = OpenMITKFile();
if (!ok)
{
this->CloseCameraConnection();
return ok;
}
try
{
SourceDataStruct* sourceDataStruct = (SourceDataStruct*) this->m_MitkImage->GetSliceData(0, 0, 0)->GetData();
memcpy(&m_DataDescription, &(sourceDataStruct->dataDescription), sizeof(m_DataDescription));
this->m_CaptureWidth = m_DataDescription.img.numColumns;
this->m_CaptureHeight = m_DataDescription.img.numRows;
if ( this->m_CaptureWidth > 10000 || this->m_CaptureHeight > 10000 ) {
MITK_ERROR << "File " << this->m_InputFileName.c_str() << " is not a ToF format!";
return false;
}
this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
this->m_NumberOfBytes = this->m_PixelNumber * sizeof(float);
this->m_SourceDataSize = m_DataDescription.size;
this->m_SourceDataStructSize = m_DataDescription.size + sizeof(PMDDataDescription);
}
catch (...)
{
MITK_ERROR << "File " << this->m_InputFileName.c_str() << " is not a ToF format!";
return false;
}
MITK_INFO << "Open MITK file: " << this->m_InputFileName.c_str();
return true;
}
//
// Find or create the linker for a package.
//
FLinkerLoad* GetPackageLinker
(
UPackage* InOuter,
const TCHAR* InLongPackageName,
uint32 LoadFlags,
UPackageMap* Sandbox,
FGuid* CompatibleGuid
)
{
// See if there is already a linker for this package.
auto Result = FLinkerLoad::FindExistingLinkerForPackage(InOuter);
// Try to load the linker.
// See if the linker is already loaded.
if (Result)
{
return Result;
}
FString NewFilename;
if( !InLongPackageName )
{
// Resolve filename from package name.
if( !InOuter )
{
// try to recover from this instead of throwing, it seems recoverable just by doing this
FText ErrorText(LOCTEXT("PackageResolveFailed", "Can't resolve asset name"));
LogGetPackageLinkerError(Result, InLongPackageName, ErrorText, ErrorText, InOuter, LoadFlags);
return nullptr;
}
FString NativeFilename;
FString LocalizedFilename;
const bool DoesNativePackageExist = FPackageName::DoesPackageExist(InOuter->GetName(), CompatibleGuid, &NativeFilename, false);
const bool DoesLocalizedPackageExist = FPackageName::DoesPackageExist(InOuter->GetName(), CompatibleGuid, &LocalizedFilename, true);
// If we are the editor, we must have a native package. If we are the game, we must have a localized package or a native package.
if ( (GIsEditor && !DoesNativePackageExist) || (!GIsEditor && !DoesLocalizedPackageExist && !DoesNativePackageExist) )
{
// In memory-only packages have no linker and this is ok.
if (!(LoadFlags & LOAD_AllowDll) && !(InOuter->PackageFlags & PKG_InMemoryOnly))
{
FUObjectThreadContext& ThreadContext = FUObjectThreadContext::Get();
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("AssetName"), FText::FromString(InOuter->GetName()));
Arguments.Add(TEXT("PackageName"), FText::FromString(ThreadContext.SerializedPackageLinker ? *(ThreadContext.SerializedPackageLinker->Filename) : TEXT("NULL")));
LogGetPackageLinkerError(Result, ThreadContext.SerializedPackageLinker ? *ThreadContext.SerializedPackageLinker->Filename : nullptr,
FText::Format(LOCTEXT("PackageNotFound", "Can't find file for asset '{AssetName}' while loading {PackageName}."), Arguments),
LOCTEXT("PackageNotFoundShort", "Can't find file for asset."),
InOuter,
LoadFlags);
}
return nullptr;
}
// The editor must not redirect packages for localization.
if (GIsEditor)
{
NewFilename = NativeFilename;
}
else
{
if (DoesLocalizedPackageExist)
{
NewFilename = LocalizedFilename;
}
// If we are the game, we can fallback to the native package, but must issue a warning.
else
{
// In memory-only packages have no linker and this is ok.
if (!(LoadFlags & LOAD_AllowDll) && !(InOuter->PackageFlags & PKG_InMemoryOnly))
{
FUObjectThreadContext& ThreadContext = FUObjectThreadContext::Get();
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("AssetName"), FText::FromString(InOuter->GetName()));
Arguments.Add(TEXT("PackageName"), FText::FromString(ThreadContext.SerializedPackageLinker ? *(ThreadContext.SerializedPackageLinker->Filename) : TEXT("NULL")));
LogGetPackageLinkerError(Result, ThreadContext.SerializedPackageLinker ? *ThreadContext.SerializedPackageLinker->Filename : nullptr,
FText::Format(LOCTEXT("PackageNotFound", "Can't find localized file for asset '{AssetName}' while loading {PackageName}."), Arguments),
LOCTEXT("PackageNotFoundShort", "Can't find localized file for asset."),
InOuter,
LoadFlags);
}
NewFilename = NativeFilename;
}
}
}
else
{
FString PackageName(InLongPackageName);
if (!FPackageName::TryConvertFilenameToLongPackageName(InLongPackageName, PackageName))
{
// try to recover from this instead of throwing, it seems recoverable just by doing this
FText ErrorText(LOCTEXT("PackageResolveFailed", "Can't resolve asset name"));
LogGetPackageLinkerError(Result, InLongPackageName, ErrorText, ErrorText, InOuter, LoadFlags);
return nullptr;
}
UPackage* ExistingPackage = FindObject<UPackage>(nullptr, *PackageName);
if (ExistingPackage)
{
if (!ExistingPackage->GetOuter() && (ExistingPackage->PackageFlags & PKG_InMemoryOnly))
{
// This is a memory-only in package and so it has no linker and this is ok.
return nullptr;
}
}
// Verify that the file exists.
FString NativeFilename;
FString LocalizedFilename;
const bool DoesNativePackageExist = FPackageName::DoesPackageExist(PackageName, CompatibleGuid, &NativeFilename, false);
const bool DoesLocalizedPackageExist = FPackageName::DoesPackageExist(PackageName, CompatibleGuid, &LocalizedFilename, true);
if( (GIsEditor && !DoesNativePackageExist) || (!GIsEditor && !DoesLocalizedPackageExist && !DoesNativePackageExist) )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("Filename"), FText::FromString(InLongPackageName));
// try to recover from this instead of throwing, it seems recoverable just by doing this
LogGetPackageLinkerError(Result, InLongPackageName, FText::Format(LOCTEXT("FileNotFound", "Can't find file '{Filename}'"), Arguments), LOCTEXT("FileNotFoundShort", "Can't find file"), InOuter, LoadFlags);
return nullptr;
}
// The editor must not redirect packages for localization.
if (GIsEditor)
{
NewFilename = NativeFilename;
}
else
{
// Use the localized package if possible.
if (DoesLocalizedPackageExist)
{
NewFilename = LocalizedFilename;
}
// If we are the game, we can fallback to the native package.
else
{
NewFilename = NativeFilename;
}
}
// Create the package with the provided long package name.
UPackage* FilenamePkg = (ExistingPackage ? ExistingPackage : CreatePackage(nullptr, *PackageName));
if (FilenamePkg != ExistingPackage && (LoadFlags & LOAD_PackageForPIE))
{
FilenamePkg->PackageFlags |= PKG_PlayInEditor;
}
// If no package specified, use package from file.
if (!InOuter)
{
if( !FilenamePkg )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("Filename"), FText::FromString(InLongPackageName));
LogGetPackageLinkerError(Result, InLongPackageName, FText::Format(LOCTEXT("FilenameToPackage", "Can't convert filename '{Filename}' to asset name"), Arguments), LOCTEXT("FilenameToPackageShort", "Can't convert filename to asset name"), InOuter, LoadFlags);
return nullptr;
}
InOuter = FilenamePkg;
Result = FLinkerLoad::FindExistingLinkerForPackage(InOuter);
}
else if (InOuter != FilenamePkg) //!!should be tested and validated in new UnrealEd
{
// Loading a new file into an existing package, so reset the loader.
//UE_LOG(LogLinker, Log, TEXT("New File, Existing Package (%s, %s)"), *InOuter->GetFullName(), *FilenamePkg->GetFullName() );
ResetLoaders( InOuter );
}
}
#if 0
// Make sure the package is accessible in the sandbox.
if( Sandbox && !Sandbox->SupportsPackage(InOuter) )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("AssetName"), FText::FromString(InOuter->GetName()));
LogGetPackageLinkerError(Result, InLongPackageName, FText::Format(LOCTEXT("Sandbox", "Asset '{AssetName}' is not accessible in this sandbox"), Arguments), LOCTEXT("SandboxShort", "Asset is not accessible in this sandbox"), InOuter, LoadFlags);
return nullptr;
}
#endif
// Create new linker.
if( !Result )
{
check(IsLoading());
// we will already have found the filename above
check(NewFilename.Len() > 0);
Result = FLinkerLoad::CreateLinker( InOuter, *NewFilename, LoadFlags );
}
// Verify compatibility.
if (Result && CompatibleGuid && Result->Summary.Guid != *CompatibleGuid)
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("AssetName"), FText::FromString(InOuter->GetName()));
// This should never fire, because FindPackageFile should never return an incompatible file
LogGetPackageLinkerError(Result, InLongPackageName, FText::Format(LOCTEXT("PackageVersion", "Asset '{AssetName}' version mismatch"), Arguments), LOCTEXT("PackageVersionShort", "Asset version mismatch"), InOuter, LoadFlags);
return nullptr;
}
return Result;
}
void WinFileStream::flush()
{
assert(INVALID_HANDLE_VALUE != m_hFile);
if (!FlushFileBuffers(m_hFile))
throw IOException(ErrorText(GetLastError()).c_str());
}
bool ToFCameraPMDController::GetDistances(float* distanceArray)
{
this->m_PMDRes = pmdGetDistances(m_PMDHandle, distanceArray, this->m_NumberOfBytes);
return ErrorText(this->m_PMDRes);
}
DWORD
WINAPI
ep_DriverService(void *arg)
{
const CONFIG_DATA *cd = GetConfigData();
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
// Build the threadpool
POOL_DATA pd;
ZeroMemory(&pd, sizeof(POOL_DATA));
pd.hSharedDriverHandle = g_hDriver;
const DWORD dwNumChannels = NUM_EVENTTYPES-1; // -1 to ignore EVENT_NONE
THREADPOOL *tp = ThreadPoolAlloc(cd->dThreadPoolSize, dwNumChannels, PfWorkerInit, PfWorkerWork, PfWorkerDestroy, &pd, sizeof(WORKER_DATA), THREAD_PRIORITY_NORMAL);
if (!tp) Die("Unable to allocate threadpool");
// Create the read file event for use with overlapped I/O
HANDLE hReadFileEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (hReadFileEvent == NULL) Die("Unable to create read file event");
// Allocate memory for the buffer to be read from the kernel
PROCFILTER_REQUEST *req = (PROCFILTER_REQUEST*)_malloca(PROCFILTER_REQUEST_SIZE);
while (true) {
if (WaitForSingleObject(g_hStopTheadEvent, 0) == WAIT_OBJECT_0) break;
// Read request from driver using synch/asynch calls according to https://support.microsoft.com/en-us/kb/156932
DWORD dwBytesRead = 0;
OVERLAPPED overlapped;
ZeroMemory(&overlapped, sizeof(OVERLAPPED));
ResetEvent(hReadFileEvent);
overlapped.hEvent = hReadFileEvent;
BOOL rc = ReadFile(g_hDriver, req, PROCFILTER_REQUEST_SIZE, &dwBytesRead, &overlapped);
DWORD dwErrorCode = GetLastError();
if (rc) {
// Successfully completed a synchronous read, do nothing
} else if (dwErrorCode == ERROR_IO_PENDING) {
// Successfully completed an asynchronous read, so wait for it
DWORD dwNumberOfBytesTransferred = 0;
if (!GetOverlappedResult(g_hDriver, &overlapped, &dwNumberOfBytesTransferred, TRUE)) {
dwErrorCode = GetLastError();
if (dwErrorCode == ERROR_OPERATION_ABORTED || dwErrorCode == ERROR_INVALID_HANDLE) break;
// Cancel the pending IO to ensure the IO operation does not complete after this function ends
// and the result is stored to an invalid location
CancelIo(g_hDriver);
Die("GetOverlappedResult() failure in reader: %d", dwErrorCode);
}
dwErrorCode = GetLastError();
dwBytesRead = dwNumberOfBytesTransferred;
} else if (dwErrorCode == ERROR_OPERATION_ABORTED || dwErrorCode == ERROR_INVALID_HANDLE) {
break;
} else {
Die("Unable to read data from driver: %d / %ls", dwErrorCode, ErrorText(dwErrorCode));
}
LogDebugFmt("Read event from driver: PID:%u Event:%u", req->dwProcessId, req->dwEventType);
ULONG64 ulStartPerformanceCount = GetPerformanceCount();
// Validate the size of data read
if (dwBytesRead < sizeof(PROCFILTER_REQUEST) || dwBytesRead > PROCFILTER_REQUEST_SIZE) {
Die("Read invalid size from driver device: %u < %u || %u > %u ReadFile:%hs ErrorCode:%d",
dwBytesRead, sizeof(PROCFILTER_REQUEST), dwBytesRead, PROCFILTER_REQUEST_SIZE, rc ? "TRUE" : "FALSE", dwErrorCode);
}
if (dwBytesRead != req->dwRequestSize) {
Die("Read partial packet from driver device: Read:%u PacketSize:%u", dwBytesRead, req->dwRequestSize);
}
// Post a copy of the retrieved data to a worker thread
LogDebug("Posting work task to worker");
// Allocate memory for the task data, the structure of which includes only the header portion of the procfilter request,
// so allocate only the exact size needed
WORKER_TASK_DATA *wtd = (WORKER_TASK_DATA*)malloc(sizeof(WORKER_TASK_DATA) + (dwBytesRead - sizeof(PROCFILTER_REQUEST)));
if (!wtd) Die("Memory allocation failure for ProcFilter request");
memcpy(&wtd->peProcFilterRequest, req, dwBytesRead);
wtd->ulStartPerformanceCount = ulStartPerformanceCount;
LogDebugFmt("Posting to threadpool: PID:%u Event:%u", req->dwProcessId, req->dwEventType);
if (ThreadPoolPost(tp, req->dwEventType, false, g_hStopTheadEvent, wtd)) {
LogDebug("Posted work task to worker");
} else {
LogDebugFmt("Failed to post task to worker");
free(wtd);
}
}
_freea(req);
ThreadPoolFree(tp);
CloseHandle(hReadFileEvent);
// Driver closing is done here since this thread could terminate due to an error situation
// and if closing were done elsewhere (such as service exit) the driver device would be kept open, consequently
// blocking process creation events until service shutdown
CloseHandle(g_hDriver);
g_hDriver = INVALID_HANDLE_VALUE;
return 0;
}
void
LoadKernelDriver()
{
CONFIG_DATA *cd = GetConfigData();
// Open the service control manager
g_hSCM = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);
if (!g_hSCM) Die("Unable to open the service control manager");
// Stop the old driver service if its running
g_hDriverService = OpenService(g_hSCM, PROCFILTER_DRIVER_SERVICE_NAME, SERVICE_START | SERVICE_STOP | DELETE | SERVICE_QUERY_STATUS);
if (g_hDriverService) {
if (!ServiceStop(g_hDriverService, 2 * 60 * 1000)) Die("Unable to stop previously running driver service");
LogDebugFmt("Opened driver service");
} else {
Die("Unable to open old driver service: %u", GetLastError());
}
// Service handle opened and the driver is to be started
// Start the driver service
BOOL rc = StartService(g_hDriverService, 0, NULL);
DWORD dwErrorCode = GetLastError();
if (!rc) Die("Unable to start driver service: %u", dwErrorCode);
// It's running, so open it
g_hDriver = CreateFileW(PROCFILTER_DEVICE_PATH, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
if (g_hDriver == INVALID_HANDLE_VALUE) {
DWORD dwErrorCode = GetLastError();
LogCriticalFmt("Error opening driver: 0x%08X", dwErrorCode);
Die("Error opening driver service %ls: %ls", cd->szProcFilterDriver, ErrorText(dwErrorCode));
}
// Send the driver its configuration
PROCFILTER_CONFIGURATION yc;
ZeroMemory(&yc, sizeof(PROCFILTER_CONFIGURATION));
yc.dwProcFilterRequestSize = sizeof(PROCFILTER_REQUEST);
yc.dwProcMaxFilterRequestSize = PROCFILTER_REQUEST_SIZE;
yc.bDenyProcessCreationOnFailedScan = cd->bDenyProcessCreationOnFailedScan;
// Always force thread/image events on in debug builds
#if defined(_DEBUG)
yc.bWantThreadEvents = true;
yc.bWantImageLoadEvents = true;
#else
yc.bWantThreadEvents = ApiWantThreadEvents();
yc.bWantImageLoadEvents = cd->bScanFileOnImageLoad || cd->bScanMemoryOnImageLoad || ApiWantImageLoadEvents();
#endif
// Create the event to be signalled when device configuration succeeds
HANDLE hControlDeviceEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!hControlDeviceEvent) Die("Unable to create event for DeviceIoControl()");
OVERLAPPED overlapped;
ZeroMemory(&overlapped, sizeof(OVERLAPPED));
overlapped.hEvent = hControlDeviceEvent;
rc = DeviceIoControl(g_hDriver, IOCTL_PROCFILTER_CONFIGURE, &yc, sizeof(PROCFILTER_CONFIGURATION), NULL, 0, NULL, &overlapped);
if (!rc && GetLastError() == ERROR_IO_PENDING) {
DWORD dwBytesRead = 0;
if (!GetOverlappedResult(g_hDriver, &overlapped, &dwBytesRead, TRUE)) {
Die("GetOverlappedResult() failure for DeviceIoControl(): %d", GetLastError());
}
} else if (!rc) {
Die("DeviceIoControl() failure: %d", GetLastError());
}
CloseHandle(hControlDeviceEvent);
LogWarning("Started driver");
}
bool ToFCameraPMDController::GetIntensities(char* sourceData, float* intensityArray)
{
this->m_PMDRes = pmdCalcIntensities(m_PMDHandle, intensityArray, this->m_NumberOfBytes, m_DataDescription, &((SourceDataStruct*)sourceData)->sourceData);
return ErrorText(this->m_PMDRes);
}
bool ToFCameraPMDController::GetAmplitudes(float* amplitudeArray)
{
this->m_PMDRes = pmdGetAmplitudes(m_PMDHandle, amplitudeArray, this->m_NumberOfBytes);
return ErrorText(this->m_PMDRes);
}
bool ToFCameraPMDController::UpdateCamera()
{
m_PMDRes = pmdUpdate(m_PMDHandle);
return ErrorText(m_PMDRes);
}
bool ToFCameraPMDController::GetIntensities(float* intensityArray)
{
this->m_PMDRes = pmdGetIntensities(m_PMDHandle, intensityArray, this->m_NumberOfBytes);
return ErrorText(this->m_PMDRes);
}
//
// Find or create the linker for a package.
//
ULinkerLoad* GetPackageLinker
(
UPackage* InOuter,
const TCHAR* InLongPackageName,
uint32 LoadFlags,
UPackageMap* Sandbox,
FGuid* CompatibleGuid
)
{
// See if there is already a linker for this package.
ULinkerLoad* Result = ULinkerLoad::FindExistingLinkerForPackage(InOuter);
// Try to load the linker.
// See if the linker is already loaded.
if( Result )
{
return Result;
}
FString NewFilename;
if( !InLongPackageName )
{
// Resolve filename from package name.
if( !InOuter )
{
// try to recover from this instead of throwing, it seems recoverable just by doing this
FText ErrorText(LOCTEXT("PackageResolveFailed", "Can't resolve asset name"));
LogGetPackageLinkerError(Result, InLongPackageName, ErrorText, ErrorText, InOuter, LoadFlags);
return nullptr;
}
if( !FPackageName::DoesPackageExist(InOuter->GetName(), CompatibleGuid, &NewFilename) )
{
// Compiled in packages have no linker and this is ok
if (!(LoadFlags & LOAD_AllowDll) && !(InOuter->PackageFlags & PKG_CompiledIn))
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("AssetName"), FText::FromString(InOuter->GetName()));
Arguments.Add(TEXT("PackageName"), FText::FromString(GSerializedPackageLinker ? *(GSerializedPackageLinker->Filename) : TEXT("NULL")));
LogGetPackageLinkerError(Result, GSerializedPackageLinker ? *GSerializedPackageLinker->Filename : nullptr,
FText::Format(LOCTEXT("PackageNotFound", "Can't find file for asset '{AssetName}' while loading {PackageName}."), Arguments),
LOCTEXT("PackageNotFoundShort", "Can't find file for asset."),
InOuter,
LoadFlags);
}
return nullptr;
}
}
else
{
FString PackageName(InLongPackageName);
if (!FPackageName::TryConvertFilenameToLongPackageName(InLongPackageName, PackageName))
{
// try to recover from this instead of throwing, it seems recoverable just by doing this
FText ErrorText(LOCTEXT("PackageResolveFailed", "Can't resolve asset name"));
LogGetPackageLinkerError(Result, InLongPackageName, ErrorText, ErrorText, InOuter, LoadFlags);
return nullptr;
}
if (UPackage* ExistingPackage = FindObject<UPackage>(nullptr, *PackageName))
{
if (!ExistingPackage->GetOuter() && (ExistingPackage->PackageFlags & PKG_CompiledIn))
{
// this is a compiled in package and so it has no linker and this is ok
return nullptr;
}
}
// Verify that the file exists.
if( !FPackageName::DoesPackageExist( PackageName, CompatibleGuid, &NewFilename ) )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("Filename"), FText::FromString(InLongPackageName));
// try to recover from this instead of throwing, it seems recoverable just by doing this
LogGetPackageLinkerError(Result, InLongPackageName, FText::Format(LOCTEXT("FileNotFound", "Can't find file '{Filename}'"), Arguments), LOCTEXT("FileNotFoundShort", "Can't find file"), InOuter, LoadFlags);
return nullptr;
}
// Create the package with the provided long package name.
UPackage* FilenamePkg = CreatePackage(nullptr, *PackageName);
if (LoadFlags & LOAD_PackageForPIE)
{
FilenamePkg->PackageFlags |= PKG_PlayInEditor;
}
// If no package specified, use package from file.
if (!InOuter)
{
if( !FilenamePkg )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("Filename"), FText::FromString(InLongPackageName));
LogGetPackageLinkerError(Result, InLongPackageName, FText::Format(LOCTEXT("FilenameToPackage", "Can't convert filename '{Filename}' to asset name"), Arguments), LOCTEXT("FilenameToPackageShort", "Can't convert filename to asset name"), InOuter, LoadFlags);
return nullptr;
}
InOuter = FilenamePkg;
Result = ULinkerLoad::FindExistingLinkerForPackage(InOuter);
}
else if (InOuter != FilenamePkg) //!!should be tested and validated in new UnrealEd
{
// Loading a new file into an existing package, so reset the loader.
//UE_LOG(LogLinker, Log, TEXT("New File, Existing Package (%s, %s)"), *InOuter->GetFullName(), *FilenamePkg->GetFullName() );
ResetLoaders( InOuter );
}
}
#if 0
// Make sure the package is accessible in the sandbox.
if( Sandbox && !Sandbox->SupportsPackage(InOuter) )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("AssetName"), FText::FromString(InOuter->GetName()));
LogGetPackageLinkerError(Result, InLongPackageName, FText::Format(LOCTEXT("Sandbox", "Asset '{AssetName}' is not accessible in this sandbox"), Arguments), LOCTEXT("SandboxShort", "Asset is not accessible in this sandbox"), InOuter, LoadFlags);
return nullptr;
}
#endif
// Create new linker.
if( !Result )
{
check(IsLoading());
// we will already have found the filename above
check(NewFilename.Len() > 0);
Result = ULinkerLoad::CreateLinker( InOuter, *NewFilename, LoadFlags );
}
// Verify compatibility.
if( CompatibleGuid && Result->Summary.Guid!=*CompatibleGuid )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("AssetName"), FText::FromString(InOuter->GetName()));
// This should never fire, because FindPackageFile should never return an incompatible file
LogGetPackageLinkerError(Result, InLongPackageName, FText::Format(LOCTEXT("PackageVersion", "Asset '{AssetName}' version mismatch"), Arguments), LOCTEXT("PackageVersionShort", "Asset version mismatch"), InOuter, LoadFlags);
return nullptr;
}
return Result;
}
int main(int argc, char **argv)
{
int ADCvalue01 = 0;
int StepSpeed = 100; //Stepping speed (smaler value = faster)
int i = 0;
int KeyHit = 0;
int KeyCode[5];
int SingleKey=0;
char TextLine[300];
char FileName[100] = "";
char FileNameOld[100] = "";
char FullFileName[300];
char a;
char IsDigit[]="-1234567890";
int ReadState = 0;
int MenueLevel = 0;
int FileSelected = 0;
int FileStartRow = 0;
int stopPlot = 0;
long xMin = 1000000, xMax = -1000000;
long yMin = 1000000, yMax = -1000000;
long coordinateCount = 0;
long coordinatePlot = 0;
long currentPlotX = 0, currentPlotY = 0, currentPlotDown = 1;
long xNow = 0, yNow = 0, zNow = 0;
char *pEnd;
FILE *PlotFile;
double Scale = 1.0;
double OldScale = 1.0;
double PicWidth = 0.0;
double PicHeight = 0.0;
long MoveLength = 100;
long OldMoveLength = 200;
long PlotStartTime = 0;
int MoveFinished = 0;
long stepPause = 5000;
long stepPauseNormal = 5000;
long stepPauseMaterial = 20000;
long zHub = 200;
int plotterMode = 1;
char FileInfo[3];
long FileSize;
long LongTemp;
long DataOffset;
long HeaderSize;
long PictureWidth;
long PictureHeight;
int IntTemp;
int ColorDepth;
long CompressionType;
long PictureSize;
long XPixelPerMeter;
long YPixelPerMeter;
long ColorNumber;
long ColorUsed;
int PixelRed, PixelGreen, PixelBlue;
int PixOK = 0;
long StepsPerPixelX = 50, StepsPerPixelY = 50;
long JetOffset1 = 40, JetOffset2 = 40;
//Mapping between wiringPi and pin order of my I/O board.
//This was necessary, because I used a wrong description of the GPIOs
//You have to change the order according to your board!
//@@@THESE ARE ALL OUTPUS!!
strcpy(FileName, "noFiLE");
if (wiringPiSetup () == -1){
printf("Could not run wiringPiSetup!");
exit(1);
}
getmaxyx(stdscr, MaxRows, MaxCols);
MessageY = MaxRows-3;
clrscr(1, MaxRows);
PrintRow('-', MessageY - 1);
initscr();
noecho();
cbreak();
start_color();
while(!quit)
{
clearScreen();
char * choices[] = {"Plot File","Manual Control","Servo Control","Opto Sensor Control","X&Y Control","initalize","Exit"};
char *description[] = {
"You select a file to plot and will plot the file on the plotter",
"Will give you full control over the plotter for debuging or demenstration",
"Lets you enter and test different duration of pulses sent to the servo for fine tuning and debugging",
"Will read in the togleing of the opto sensor for debuging",
"Will let you have control how much to move in x and y by ticks more precisly",
"Test initalization procedure",
"Will exit the prgram"};
int result = menus("Hello and Welcome to my creation please sleect a mode", choices,description,7,20);
switch (result)
{
case 1: ;
/* FILE * fp;
char * line = NULL;
size_t len = 0;
ssize_t read;
fp = fopen ("sampleGcode.txt","r");*/
//Plot file
char dir[1024];
getcwd(dir,sizeof(dir));
MessageText("3 seconds until plotting starts !!!!!!!!!!!!!!!!!", 1, 2, 0);
delay(3000);
if((PlotFile=chooseFile(dir))==NULL){
sprintf(TextLine, "Can't open file '%s'!\n", FullFileName);
strcpy(FileName, "NoFiLE");
ErrorText(TextLine);
}
else{
currentPlotX = 0;
currentPlotY = 0;
PlotStartTime = time(0);
PrintMenue_03(FullFileName, coordinateCount, 0, 0, 0, PlotStartTime,Scale);
coordinatePlot = 0;
stopPlot = 0;
if(currentPlotDown == 1){
penMove(1);
currentPlotDown = 0;
}
while(!(feof(PlotFile)) && stopPlot == 0){
fread(&a, 1, 1, PlotFile);
if(a == '>'){
ReadState = 0;
}
if(ReadState == 0 || ReadState == 1){
TextLine[i] = a;
TextLine[i+1] = '\0';
i++;
}
if(ReadState == 2 || ReadState == 3){
if(strchr(IsDigit, a) != NULL){
TextLine[i] = a;
TextLine[i+1] = '\0';
i++;
}
}
if(ReadState == 2){
if(strchr(IsDigit, a) == NULL){
if(strlen(TextLine) > 0){
xNow = (strtol(TextLine, &pEnd, 10) - xMin) * 0.33333 * Scale;
ReadState = 3;
i=0;
TextLine[0]='\0';
}
}
}
if(ReadState == 3){
if(strchr(IsDigit, a) == NULL){
if(strlen(TextLine) > 0){
yNow = ((yMax - strtol(TextLine, &pEnd, 10)) - yMin) * 0.33333 * Scale;//Flip around y-axis
coordinatePlot++;
PrintMenue_03(FullFileName, coordinateCount, coordinatePlot, xNow, yNow, PlotStartTime, Scale);
if(stopPlot == 0){
stopPlot =0;
moveXY(xNow - currentPlotX, yNow - currentPlotY);
currentPlotX = xNow;
currentPlotY = yNow;
// sprintf(TextLine, "xNow=%ld, yNow=%ld", xNow, yNow);
// MessageText(TextLine, MessageX+1, MessageY+1, 0);
// getch();
}
else{
if(currentPlotDown == 1){
if(plotterMode == 1){
penMove(1);
}
currentPlotDown = 0;
}
}
if(currentPlotDown == 0){
if(stopPlot == 0){
penMove(0);
currentPlotDown = 1;
}
}
ReadState = 2;
i=0;
TextLine[0]='\0';
}
}
}
if(strcmp(TextLine, "<path") == 0){
if(currentPlotDown == 1){
penMove(1);
currentPlotDown = 0;
}
ReadState = 2;
i = 0;
TextLine[0]='\0';
}
if(a == '<'){
i = 1;
TextLine[0] = a;
TextLine[1] = '\0';
ReadState = 1;
}
}
fclose(PlotFile);
if(currentPlotDown == 1){
penMove(1);
currentPlotDown = 0;
}
PrintMenue_03(FullFileName, coordinateCount, coordinatePlot, 0, 0, PlotStartTime,Scale);
moveXY(-currentPlotX, -currentPlotY);
currentPlotX = 0;
currentPlotY = 0;
while(kbhit()){
getch();
}
MessageText("Finished! Press any key to return to main menu.", MessageX, MessageY, 0);
getch();
break;
}
break;
case 2:
manualControl();
break;
case 3:
servoControl();
break;
case 4:
optoControl();
break;
case 5:
xyControl();
break;
case 6:
initalize();
break;
case -1:
default:
system("reset");
quit=true;
break;
}
}
allSTOP();
endwin();
return 0;
}
