julia.cpp
//-----------------------------------------------------------------------------
//$Id: julia.cpp 189 2007-04-19 10:53:38Z robin $
//
// Copyright (c) 2006 Zanja Technologies, Inc
//
// TRADE SECRETS: PROPRIETARY AND CONFIDENTIAL
// Unpublished material - all rights reserved under the
// Copyright Laws of the United States.
//
// Distributed under license by ESRI, Inc.
// For additional information, contact:
// Environmental Systems Research Institute, Inc.
// 380 New York Street
// Redlands, California, USA 92373
//
/*! \file julia.cpp
\brief <TODO: insert file description here>
\author Robin Princeley
\date $Date: 2007-04-19 14:53:38 +0400 (Thu, 19 Apr 2007) $
\version $Revision: 189 $
*/
//-----------------------------------------------------------------------------
#include "julia.h"
#define PLUGIN_NAME "julia"
#define PLUGIN_DESCRIPTION "Sample SDK plugin"
#define PLUGIN_COPYRIGHT "Copyright (c) 2006 Zanja Technologies Inc."
#define PLUGIN_VERSION 1.0f
// Utility functions
template < class T > T* createObject()
{
return new T;
}
template < class T > void deleteObject( T* &obj )
{
if ( obj ) {
delete obj;
obj = 0;
}
}
void copy( FC_ImageInformation &info1, const FC_ImageInformation &info2 )
{
info1.width = info2.width;
info1.height = info2.height;
info1.bands = info2.bands;
info1.bits = info2.bits;
info1.colorSpace = info2.colorSpace;
info1.dataType = info2.dataType;
info1.tileWidth = info2.tileWidth;
info1.tileHeight = info2.tileHeight;
info1.layerType = info2.layerType;
info1.layout = info2.layout;
info1.byteorder = info2.byteorder;
}
// Initialization function
int32_t FC_PLUGIN_CALL FormatCorePlugin_InitializePlugin( FC_PluginInformation *info, const FC_ApplicationData *appdata )
{
// FormatCore is not used, set version to -1.00
info->formatcoreVersion = -1.00;
// Return some details about this plugin
// Version number
info->pluginVersion = PLUGIN_VERSION;
// Name
strncpy( info->name, PLUGIN_NAME, min( strlen( PLUGIN_NAME ), 255 ) );
// Description
strncpy( info->description, PLUGIN_DESCRIPTION, min( strlen( PLUGIN_DESCRIPTION ), 255 ) );
// Copyright
strncpy( info->copyright, PLUGIN_COPYRIGHT, min( strlen( PLUGIN_COPYRIGHT ), 255 ) );
return FORMATCORE_SUCCESS;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_ShutdownPlugin()
{
// Do any cleanup here
return FORMATCORE_SUCCESS;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_GetPluginProperty( uint32_t id,
char *value,
uint32_t *length )
{
switch ( id ) {
default:
return FORMATCORE_FAILURE;
break;
}
return FORMATCORE_SUCCESS;
}
uint32_t FC_PLUGIN_CALL FormatCorePlugin_GetImageCount( const char *filename,
uint32_t *count )
{
// Return the number of images ( full + overviews ) in specified file
if ( !JuliaPluginReader::getOverviewCount( filename, *count ) ) {
return FORMATCORE_FAILURE;
}
return FORMATCORE_SUCCESS;
}
FC_ImageHandle FC_PLUGIN_CALL FormatCorePlugin_CreateReader()
{
JuliaPluginReader *reader = 0;
// Create actual class, allocate any resources required here
reader = createObject< JuliaPluginReader >();
if ( !reader ) {
return 0;
}
return reader;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_DestroyReader( FC_ImageHandle handle )
{
JuliaPluginReader *reader = reinterpret_cast< JuliaPluginReader* > ( handle );
// Destroy class, resources associated with handle
deleteObject( reader );
return FORMATCORE_SUCCESS;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_OpenImage( void * handle, const char *filename,
uint32_t layer, uint32_t slice,
const FC_Parameter *parameters, uint32_t parameter_count,
const FC_ApplicationData *appdata )
{
JuliaPluginReader *reader = reinterpret_cast< JuliaPluginReader* > ( handle );
if ( !reader ) {
return FORMATCORE_INVALID_HANDLE;
}
// Open image specified, layer is a 0 based index ( 0 bring full resolution or first image
if ( !reader->open( filename, layer, slice, parameters, parameter_count ) ) {
return FORMATCORE_FAILURE;
}
return FORMATCORE_SUCCESS;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_CloseImage( FC_ImageHandle handle )
{
JuliaPluginReader *reader = reinterpret_cast< JuliaPluginReader* > ( handle );
if ( !reader ) {
return FORMATCORE_INVALID_HANDLE;
}
// Close image
if ( !reader->close() ) {
deleteObject( reader );
return 1FORMATCORE_FAILURE;
}
return FORMATCORE_SUCCESS;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_SelectImageROI( FC_ImageHandle handle, const FC_ImageROI *roi,
uint32_t rows, uint32_t cols,
FC_Parameter *parameters, uint32_t parameter_count )
{
JuliaPluginReader *reader = reinterpret_cast< JuliaPluginReader* > ( handle );
if ( !reader ) {
return FORMATCORE_INVALID_HANDLE;
}
// Prepare selected ROI for reading
if ( !reader->prepare( roi, rows, cols,
parameters, parameter_count ) ) {
return FORMATCORE_FAILURE;
}
return FORMATCORE_SUCCESS;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_GetImageInformation( FC_ImageHandle handle, FC_ImageInformation *info )
{
JuliaPluginReader *reader = reinterpret_cast< JuliaPluginReader* > ( handle );
if ( !reader ) {
return FORMATCORE_INVALID_HANDLE;
}
copy( *info, *reader->getInformation() );
// Return image details
if ( !reader->getIndex() ) {
info->layerType = static_cast< uint32_t >( FC_SubsetUnrelated);
} else {
info->layerType = static_cast< uint32_t >( FC_SubsetReducedResolution );
}
return FORMATCORE_SUCCESS;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_ReadImageScanlines( FC_ImageHandle handle, byte_t **buffer, uint32_t startRow,
uint32_t rows, size_t scanlineSize, uint32_t plane )
{
JuliaPluginReader *reader = reinterpret_cast< JuliaPluginReader* > ( handle );
if ( !reader ) {
return FORMATCORE_INVALID_HANDLE;
}
// Fill and return pixel data in specified buffer
if ( !reader->readScanlines( buffer, startRow, rows, scanlineSize, plane ) ) {
return FORMATCORE_FAILURE;
}
return FORMATCORE_SUCCESS;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_ReadImageColorMap( FC_ImageHandle handle, FC_ImageColorMap *colormap )
{
uint32_t i = 0;
for ( i = 0; i < colormap->length; i++ ) {
colormap->entries[i].alpha = 255;
colormap->entries[i].red = 0;
colormap->entries[i].green = 0;
colormap->entries[i].blue = i;
}
return FORMATCORE_SUCCESS;
}
int32_t FC_PLUGIN_CALL FormatCorePlugin_GetErrorMessage( FC_ImageHandle handle,
char *msg,
uint32_t *length )
{
JuliaPluginReader *reader = reinterpret_cast< JuliaPluginReader* > ( handle );
if ( !reader ) {
return FORMATCORE_INVALID_HANDLE;
}
// This function is called in case of an error, msg should be filled. This string will end up in a user readable log.
return FORMATCORE_FAILURE;
}
/*! \func BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
\brief Win32 DLL entry point.
\param hModule Module handle.
\param ul_reason_for_call Reason for call attach/detach to thread/process.
\param lpReserved Unused reserved variable.
*/
BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved )
{
switch( ul_reason_for_call )
{
case DLL_PROCESS_ATTACH:
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}