/* =============================================================================
* parseArgs
* =============================================================================
*/
static void
parseArgs (long argc, char* const argv[])
{
long i;
long opt;
opterr = 0;
setDefaultParams();
while ((opt = getopt(argc, argv, "g:n:s:t:")) != -1) {
switch (opt) {
case 'g':
case 'n':
case 's':
case 't':
global_params[(unsigned char)opt] = atol(optarg);
break;
case '?':
default:
opterr++;
break;
}
}
for (i = optind; i < argc; i++) {
fprintf(stderr, "Non-option argument: %s\n", argv[i]);
opterr++;
}
if (opterr) {
displayUsage(argv[0]);
}
}
void STWarp<T>::init() {
setDefaultParams();
dimensions = vector<int>(5,0);
videoA = nullptr;
videoB = nullptr;
initialWarpField = nullptr;
}
static void parseArgs(long argc, char* const argv[]) {
long i;
long opt;
opterr = 0;
setDefaultParams();
while ((opt = getopt(argc, argv, "s:t:o:i:c:w:")) != -1) {
switch (opt) {
case 's':
case 'o':
case 't':
case 'i':
case 'c':
case 'w':
global_params[(unsigned char)opt] = atol(optarg);
break;
case '?':
default:
opterr++;
break;
}
}
for (i = optind; i < argc; i++) {
fprintf(stderr, "Non-option argument: %s\n", argv[i]);
opterr++;
}
if (opterr) {
printf("Wrong usage\n");
exit(1);
}
}
/* =============================================================================
* parseArgs
* =============================================================================
*/
static void
parseArgs (long argc, char* const argv[])
{
long i;
long opt;
opterr = 0;
setDefaultParams();
while ((opt = getopt(argc, argv, "c:n:q:r:t:u:ALTX:Z:")) != -1) {
switch (opt) {
case 'c':
case 'n':
case 'q':
case 'r':
case 't':
case 'u':
global_params[(unsigned char)opt] = atol(optarg);
break;
case 'A':
setAdaptMode(0);
break;
case 'L':
setAdaptMode(-1);
break;
case 'T':
setAdaptMode(1);
break;
case 'X':
setTranxOvhd(atof(optarg));
break;
case 'Z':
setTranxInstr(atoi(optarg),atoi(optarg)*2);
break;
case '?':
default:
opterr++;
break;
}
}
for (i = optind; i < argc; i++) {
fprintf(stderr, "Non-option argument: %s\n", argv[i]);
opterr++;
}
if (opterr) {
displayUsage(argv[0]);
}
}
std::unique_ptr<NUGL::Texture> createCubeMapTexture(int size) {
auto tex = std::make_unique<NUGL::Texture>(GL_TEXTURE3, GL_TEXTURE_CUBE_MAP);
for (unsigned i = 0; i < 6; i++) {
tex->setTextureData(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, size, size, nullptr);
checkForAndPrintGLError(__func__, __LINE__);
}
checkForAndPrintGLError(__FILE__, __LINE__);
tex->setDefaultParams();
checkForAndPrintGLError(__func__, __LINE__);
return tex;
}
/**
* This function takes a file path (presumably to a shared library)
* and loads an environment from it into the global variable "theEnvironment"
*
* It uses the string-serialized parameterHolder in theParamString to initialize
* the environment.
*/
JNIEXPORT jboolean JNICALL Java_org_rlcommunity_rlviz_environmentshell_JNIEnvironment_JNIloadEnvironment(JNIEnv *env, jobject obj, jstring envFilePath, jstring theParamString) {
const char* stringPath=env->GetStringUTFChars(envFilePath,0);
loadEnvironmentToStructFromFile(envFuncPointers, stringPath);
int status = loadEnvironmentToStructFromFile(envFuncPointers, stringPath);
env->ReleaseStringUTFChars(envFilePath, stringPath);
if (status != DLSYM_SUCCESS)return false;
setDefaultParams(envFuncPointers, env->GetStringUTFChars(theParamString, 0));
return true;
}
// Class Instance
//-----------------------------------------------------------------------------
// Function : Instance::Instance
// Purpose : instance block constructor
// Special Notes :
// Scope : public
// Creator : Brian Fett, SNL
// Creation Date : 08/05/07
//-----------------------------------------------------------------------------
Instance::Instance(
const Configuration & configuration,
const InstanceBlock & IB,
Model & iter,
const FactoryBlock & factory_block)
: DeviceInstance(IB, configuration.getInstanceParameters(), factory_block),
model_(iter),
outCurrent(0.0),
deltaVoltage(0.0),
FAKEPARAM(0.0),
li_Pos(-1),
li_Neg(-1),
li_Out(-1),
li_Bra(-1),
ABraEquPosNodeOffset(-1),
ABraEquNegNodeOffset(-1),
AOutEquBraVarOffset(-1),
v_pos(0.0),
v_neg(0.0),
v_out(0.0),
i_bra(0.0)
{
numIntVars = 1;
numExtVars = 3;
numStateVars = 0;
if( jacStamp.empty() )
{
jacStamp.resize(4); // V1 V2 V3 I
jacStamp[2].resize(1); // N1
jacStamp[2][0] = 3; // N2
jacStamp[3].resize(2); // N3 X
jacStamp[3][0] = 0; // Br X X
jacStamp[3][1] = 1;
}
// Set params to constant default values:
setDefaultParams ();
// Set params according to instance line and constant defaults from metadata:
setParams (IB.params);
// calculate dependent (ie computed) params and check for errors:
}
/* =============================================================================
* parseArgs
* =============================================================================
*/
static void
parseArgs (long argc, char* const argv[])
{
long i;
long opt;
opterr = 0;
setDefaultParams();
while ((opt = getopt(argc, argv, "b:i:pt:x:y:z:")) != -1) {
switch (opt) {
case 'b':
case 't':
case 'x':
case 'y':
case 'z':
global_params[(unsigned char)opt] = atol(optarg);
break;
case 'i':
global_inputFile = optarg;
break;
case 'p':
global_doPrint = TRUE;
break;
case '?':
default:
opterr++;
break;
}
}
for (i = optind; i < argc; i++) {
fprintf(stderr, "Non-option argument: %s\n", argv[i]);
opterr++;
}
if (opterr) {
displayUsage(argv[0]);
}
}
static void run(
const gchar * name,
gint nparams,
const GimpParam * param,
gint * nreturn_vals,
GimpParam ** return_vals)
{
static GimpParam values[2]; /* Gimp return values. !!! Allow 2: status and error message. */
TGimpAdapterParameters pluginParameters;
TImageSynthParameters engineParameters;
GimpDrawable *drawable = NULL;
GimpDrawable *corpus_drawable = NULL;
GimpDrawable *map_in_drawable= NULL;
GimpDrawable *map_out_drawable= NULL;
gboolean ok, with_map;
/*
Local copies of pixmaps (not using gimp regions.)
2-D arrays of Pixel, addressable by Coordinates (Point).
c++: static Bitmap<Pixelel>
*/
Map targetMap;
Map corpusMap;
Map targetMaskMap;
Map corpusMaskMap;
int cancelFlag = 0;
#ifdef SYNTH_THREADED
// This is as early as it can be called. Not sure it needs to be called. See later call to it.
// Call it early since calls to gdk, gtk might require this?
g_thread_init(NULL);
#endif
#ifdef DEBUG
gimp_message_set_handler(1); // To console instead of GUI
start_time = clock();
#endif
// internationalization i18n
// Note these constants are defined in the build environment.
/* Initialize i18n support */
#if defined(G_OS_WIN32)
bindtextdomain (GETTEXT_PACKAGE, gimp_locale_directory());
#else
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
#endif
#ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
#endif
textdomain (GETTEXT_PACKAGE);
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR; /* Unless everything succeeds. */
drawable = gimp_drawable_get(param[2].data.d_drawable);
/* Check image type (could be called non-interactive) */
if (!gimp_drawable_is_rgb(drawable->drawable_id) &&
!gimp_drawable_is_gray(drawable->drawable_id))
{
ERROR_RETURN(_("Incompatible image mode."));
}
/* Deal with run mode */
ok = FALSE;
switch(param[0].data.d_int32)
{
case GIMP_RUN_INTERACTIVE :
ok = get_last_parameters(&pluginParameters,drawable->drawable_id, RESYNTH_ENGINE_PDB_NAME);
gimp_message("Resynthesizer engine should not be called interactively");
/* But keep going with last (or default) parameters, really no harm. */
break;
case GIMP_RUN_NONINTERACTIVE :
ok = get_parameters_from_list(&pluginParameters, nparams, param);
break;
case GIMP_RUN_WITH_LAST_VALS :
ok = get_last_parameters(&pluginParameters,drawable->drawable_id, RESYNTH_ENGINE_PDB_NAME);
break;
}
if (!ok)
{
ERROR_RETURN(_("Resynthesizer failed to get parameters."));
}
/* Limit neighbours parameter to size allocated. */
if (pluginParameters.neighbours > IMAGE_SYNTH_MAX_NEIGHBORS )
pluginParameters.neighbours = IMAGE_SYNTH_MAX_NEIGHBORS;
corpus_drawable = gimp_drawable_get(pluginParameters.corpus_id);
/* The target and corpus must have the same base type.
In earlier version, they must have the same bpp.
But now we don't compare the alphas, so they can differ in presence of alpha.
*/
if (! equal_basetypes(drawable, corpus_drawable) )
{
ERROR_RETURN(_("The input texture and output image must have the same number of color channels."));
}
with_map = (pluginParameters.input_map_id != -1 && pluginParameters.output_map_id != -1);
/* If only one map is passed, it is ignored quietly. */
map_in_drawable=0;
map_out_drawable=0;
if (with_map)
{
map_in_drawable = gimp_drawable_get(pluginParameters.input_map_id);
map_out_drawable = gimp_drawable_get(pluginParameters.output_map_id);
/* All these can be wrong at the same time.
Forego userfriendliness for ease of programming: abort on first error
*/
if ( ! equal_basetypes(map_in_drawable, map_out_drawable) )
{
/* Maps need the same base type. Formerly needed the same bpp. */
ERROR_RETURN(_("The input and output maps must have the same mode"));
}
if (map_in_drawable->width != corpus_drawable->width ||
map_in_drawable->height != corpus_drawable->height)
{
ERROR_RETURN(_("The input map should be the same size as the input texture image"));
}
if (map_out_drawable->width != drawable->width ||
map_out_drawable->height != drawable->height)
{
ERROR_RETURN(_("The output map should be the same size as the output image"));
}
}
/*
The engine should not be run interactively so no need to store last values.
I.E. the meaning of "last" is "last values set by user interaction".
*/
#ifdef ANIMATE
// Copy local pointer vars to globals
targetDrawableCopy = drawable;
targetMapCopy = &targetMap;
#endif
/* Error checks done, initialization work begins. So start progress callbacks. */
progressStart("Initializing...");
/*
Set flags for presence of alpha channels.
The flag is an optimization. Alternatives:
- a function
- OR standardize the internal pixmap to ALWAYS have an alpha pixelel
initialized to VISIBLE and set from any alpha pixelel.
*/
gboolean is_alpha_image = gimp_drawable_has_alpha(drawable->drawable_id);
gboolean is_alpha_corpus = gimp_drawable_has_alpha(corpus_drawable->drawable_id);
// Image adaption requires format indices
// WAS prepareImageFormatIndices(drawable, corpus_drawable, with_map, map_in_drawable);
TFormatIndices formatIndices;
guint map_count = (with_map? count_color_channels(map_in_drawable) : 0 );
prepareImageFormatIndices(
&formatIndices,
count_color_channels(drawable),
map_count,
is_alpha_image,
is_alpha_corpus,
with_map
);
#ifdef ADAPT_SIMPLE
/* Adapt Gimp to an engine with a simpler interface. */
setDefaultParams(¶meters);
ImageBuffer imageBuffer;
ImageBuffer maskBuffer;
// TODO change to new signature
adaptGimpToSimple(drawable, &imageBuffer, &maskBuffer); // From Gimp to simple
g_printf("Here3\n");
adaptSimpleAPI(&imageBuffer, &maskBuffer); // From simple to existing engine API
#else
g_printf("Gimp adaption\n");
/* target/context adaption */
fetch_image_mask_map(drawable, &targetMap, formatIndices.total_bpp,
&targetMaskMap,
MASK_TOTALLY_SELECTED,
map_out_drawable, formatIndices.map_start_bip);
#ifdef ANIMATE
clear_target_pixels(formatIndices.colorEndBip); // For debugging, blacken so new colors sparkle
#endif
/* corpus adaption */
fetch_image_mask_map(corpus_drawable, &corpusMap, formatIndices.total_bpp,
&corpusMaskMap,
MASK_TOTALLY_SELECTED,
map_in_drawable, formatIndices.map_start_bip);
// TODO These are artifacts of earlier design, not used.
free_map(&corpusMaskMap);
free_map(&targetMaskMap);
adaptParameters(&pluginParameters, &engineParameters);
#endif
// After possible adaption, check size again
g_assert(targetMap.width * targetMap.height); // Image is not empty
g_assert(corpusMap.width * corpusMap.height); // Corpus is not empty
// Done with adaption: now main image data in canonical pixmaps, etc.
// Begin real work
progressStart("synthesizing...");
int result = engine(
engineParameters,
&formatIndices,
&targetMap,
&corpusMap,
progressUpdate,
(void *) 0,
&cancelFlag
);
if (result == IMAGE_SYNTH_ERROR_EMPTY_CORPUS)
{
ERROR_RETURN(_("The texture source is empty. Does any selection include non-transparent pixels?"));
}
else if (result == IMAGE_SYNTH_ERROR_EMPTY_TARGET )
{
ERROR_RETURN(_("The output layer is empty. Does any selection have visible pixels in the active layer?"));
}
// Normal post-process adaption follows
/* dump_target_points(); */ /* detailed debugging. */
// print_post_stats();
// Update Gimp image from local pixmap
// Note this works even for test harness where ADAPT_SIMPLE
// but then it does NOT test returning results in buffer.
/*
We could test antiAdaptImage() here.
But antiAdaptImage() has already been tested once on the incoming side.
So no compelling need to test it again here.
*/
post_results_to_gimp(drawable, targetMap);
/* Clean up */
// Adapted
free_map(&targetMap);
free_map(&corpusMap);
// GIMP
detach_drawables(drawable, corpus_drawable, map_in_drawable, map_out_drawable);
gimp_progress_end();
values[0].data.d_status = GIMP_PDB_SUCCESS;
}
// Test harness, small images
// !!! Here Alpha FF is total opacity. Alpha 0 is total transparency.
int main(
)
{
// A 3x3 image where the center pixel will be synthesized
unsigned char image[42] = {
0,0,0,0, 0,0,0,1, 0,0,0,0, 0,0, // 3*RGBA and 2 trailing pad byte = 14
0,0,0,0, 1,1,1,1, 0,0,0,0, 0,0,
0,0,0,0, 0,0,0,0, 0,0,0,8, 0,0
};
unsigned char mask[12] = {
0,0, 0, 0, // 3*mask and trailing pad byte = 4
0,0xFF, 0, 0, // 0xFF == totally selected
0,0, 0, 0
};
// A 1x3 image where the middle pixel will be synthesized.
// First pixel opaque
// Third pixel transparent
unsigned char image2[14] = {
128,128,128,0xFF, 1,1,1,1, 0,0,0,0, 0,0 // 3*RGBA and 2 trailing pad byte = 14
};
unsigned char mask2[4] = {
0,0xFF,0, 0 // 3*mask and 1 trailing pad byte = 4
};
unsigned char mask3[8] = {
0, 0,0, 0, // 3*mask and 1 trailing pad byte = 4
0,0xFF,0, 0
};
unsigned char maskEmpty[4] = {
0,0,0, 0 // 3*mask and 1 trailing pad byte = 4
};
// A 1x3 image where the all pixel transparent and the middle pixel will be synthesized.
unsigned char image3[14] = {
128,128,128,0, 1,1,1,1, 0,0,0,0, 0,0 // 3*RGBA and 2 trailing pad byte
};
// A 2x3 RGB image
unsigned char imageRGB[22] = {
128,128,128, 1,1,1, 2,2,2, 5,5, // 3*RGB and 2 trailing pad byte = 11
64,64,64, 4,4,4, 3,3,3, 7,7
};
// 1x3 Grey alpha
// First pixel opaque, second to be synthesized, third transparent
unsigned char imageGrayA[8] = {
128,0xFF, 64,1, 1,0, 0,0 // 3*GA and 2 trailing pad byte = 8
};
// 1x3 Grey
unsigned char imageGray[5] = {
128, 64, 1, 0,0 // 3*GA and 2 trailing pad byte = 8
};
// !!! Note width, height, rowBytes in that order
ImageBuffer testImage = { (unsigned char*) &image, 3, 3, 14 };
ImageBuffer testImage2 = { (unsigned char*) &image2, 3, 1, 14 };
ImageBuffer testImage3 = { (unsigned char*) &image3, 3, 1, 14 };
ImageBuffer testImageRGB = { (unsigned char*) &imageRGB, 3, 2, 11 };
ImageBuffer testImageGrayA = { (unsigned char*) &imageGrayA, 3, 1, 8 };
ImageBuffer testImageGray = { (unsigned char*) &imageGray, 3, 1, 5 };
ImageBuffer testMask= { (unsigned char*) &mask, 3, 3, 4 };
ImageBuffer testMask2= { (unsigned char*) &mask2, 3, 1, 4 };
ImageBuffer testMask3= { (unsigned char*) &mask3, 3, 2, 4 };
ImageBuffer testMaskBad= { (unsigned char*) &mask3, 1, 1, 1 };
ImageBuffer testMaskEmpty= { (unsigned char*) &maskEmpty, 3, 1, 4 };
TImageSynthParameters parameters;
setDefaultParams(¶meters);
{
// !!!! Set this to 1 to test cancellation !!!!
int cancelFlag = 0;
printf("\nTest center pixel synthesized but alpha unchanged (OR test cancellation).\n");
printf("Before\n");
dumpBuffer(&testImage, 4);
imageSynth(&testImage, &testMask, T_RGBA, ¶meters, progressCallback, (void*) 0, &cancelFlag);
}
// dumpImage(45); // 45 pixelels 3x3x5
printf("After\n");
dumpBuffer(&testImage, 4);
/*
(1,1) should be changed to 0,0,0,1
i.e. the alpha byte 1 should not be changed
but the color should be 0,0,0 from unmasked and partially opaque region.
Other pixels are not changed.
*/
// Note these tests destroy the input image, which can't be used twice
test("Test mix of full transparency and opaque", &testImage2, &testMask2, T_RGBA, 4,
"80 80 80 ff 80 80 80 01 00 00 00 00", ¶meters);
test("Test RGB w/o alpha", &testImageRGB, &testMask3, T_RGB, 3,
"80 80 80 01 01 01 02 02 02\n40 40 40 01 01 01 03 03 03", ¶meters);
test("Test Gray w/ alpha", &testImageGrayA, &testMask2, T_GrayA, 2,
"80 ff 80 01 01 00", ¶meters);
// Also tests passing NULL parameters for defaults
test("Test Gray w/o alpha", &testImageGray, &testMask2, T_Gray, 1,
"80 01 01", (TImageSynthParameters*) NULL);
// Tests of error conditions.
// Errors that don't leak memory.
// Rest of tests should return errors.
test("All transparent", &testImage3, &testMask2, T_RGBA, 4,
"should be unchanged.", ¶meters);
parameters.patchSize = 65;
test("patchSize parameter out of range", &testImageGray, &testMask2, T_Gray, 1,
"80 01 01", ¶meters);
parameters.patchSize = 10;
test("mask not same size as image", &testImageGray, &testMaskBad, T_Gray, 1,
"80 01 01", ¶meters);
test("target empty (mask empty)", &testImageGray, &testMaskEmpty, T_Gray, 1,
"80 01 01", ¶meters);
return(0);
// The rest are programming errors that leak
test("Invalid image format", &testImageGray, &testMask2, 666, 1,
"80 01 01", ¶meters);
// TODO matchContextType; out of range IMAGE_SYNTH_ERROR_MATCH_CONTEXT_TYPE_RANGE
return(0);
}
