SZS v2.18a

1 files changed, 1391 insertions, 0 deletions

diff --git a/project/src/lib-transform.c b/project/src/lib-transform.c
new file mode 100644
index 0000000..e463621
--- /dev/null
+++ b/project/src/lib-transform.c
@@ -0,0 +1,1391 @@
+
+/***************************************************************************
+ *                         _______ _______ _______                         *
+ *                        |  ___  |____   |  ___  |                        *
+ *                        | |   |_|    / /| |   |_|                        *
+ *                        | |_____    / / | |_____                         *
+ *                        |_____  |  / /  |_____  |                        *
+ *                         _    | | / /    _    | |                        *
+ *                        | |___| |/ /____| |___| |                        *
+ *                        |_______|_______|_______|                        *
+ *                                                                         *
+ *                            Wiimms SZS Tools                             *
+ *                          https://szs.wiimm.de/                          *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *   This file is part of the SZS project.                                 *
+ *   Visit https://szs.wiimm.de/ for project details and sources.          *
+ *                                                                         *
+ *   Copyright (c) 2011-2020 by Dirk Clemens <wiimm@wiimm.de>              *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt       *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "lib-std.h"
+#include <math.h>
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    options			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+u32   set_flags		= M1(u32);
+bool  have_set_scale	= false;
+bool  have_set_rot	= false;
+DEFINE_VAR(set_scale);
+DEFINE_VAR(set_rot);
+
+uint	have_set_value = 0; // x=bit-0, y=bit-1, z=bit-2
+double3	set_value_min, set_value_max;
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptSetFlags ( ccp arg )
+{
+    return ScanSizeOptU32(
+		&set_flags,		// u32 * num
+		arg,			// ccp source
+		1,			// default_factor1
+		0,			// int force_base
+		"set-flag",		// ccp opt_name
+		0,			// u64 min
+		0xffff,			// u64 max
+		0,			// u32 multiple
+		0,			// u32 pow2
+		true			// bool print_err
+		) != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptSetScale ( ccp arg )
+{
+     if (!arg)
+	return 0;
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),"Option --set-scale",0);
+    enumError err = ScanVectorExprSI(&si,&set_scale,1.0,1);
+    DASSERT( set_scale.mode == VAR_VECTOR );
+    have_set_scale = !err && IsNormalD3(set_scale.v);
+    if ( err != ERR_OK )
+	err = CheckEolSI(&si);
+    ResetSI(&si);
+
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptSetRot ( ccp arg )
+{
+     if (!arg)
+	return 0;
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),"Option --set-rot",0);
+    enumError err = ScanVectorExprSI(&si,&set_rot,0.0,1);
+    DASSERT( set_rot.mode == VAR_VECTOR );
+    have_set_rot = !err && IsNormalD3(set_rot.v);
+    if ( err != ERR_OK )
+	err = CheckEolSI(&si);
+    ResetSI(&si);
+
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptSet ( uint xyz, ccp arg )
+{
+    DASSERT( xyz < 3 );
+    if ( !arg || xyz >= 3 )
+	return 0;
+
+    char optname[10];
+    snprintf(optname,sizeof(optname),"%cset",'x'+xyz);
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),optname,0);
+    DEFINE_VAR(min);
+    DEFINE_VAR(max);
+
+    const enumError err = ScanMinMaxExprSI(&si,&min,&max);
+    CheckEolSI(&si);
+    ResetSI(&si);
+    if (err)
+	return 1;
+
+    set_value_min.v[xyz] = min.v[xyz];
+    set_value_max.v[xyz] = max.v[xyz];
+    have_set_value     |= 1 << xyz;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptShift ( ccp arg )
+{
+     if (!arg)
+	return 0;
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),"Option --shift",0);
+
+    DEFINE_VAR(temp);
+    const enumError err = ScanVectorExprSI(&si,&temp,0.0,1);
+    DASSERT( temp.mode == VAR_VECTOR );
+    CheckEolSI(&si);
+    ResetSI(&si);
+
+    if (!err)
+	SetShiftMatrixD(&opt_transform,&temp.d3);
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptTranslate ( ccp arg )
+{
+     if (!arg)
+	return 0;
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),"Option --translate",0);
+
+    DEFINE_VAR(temp);
+    const enumError err = ScanVectorExprSI(&si,&temp,0.0,1);
+    DASSERT( temp.mode == VAR_VECTOR );
+    CheckEolSI(&si);
+    ResetSI(&si);
+
+    if (!err)
+	SetTranslateMatrixD(&opt_transform,&temp.d3);
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptScale ( ccp arg )
+{
+     if (!arg)
+	return 0;
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),"Option --scale",0);
+    ScanFile_t *sf = si.cur_file;
+    DASSERT(sf);
+
+    DEFINE_VAR(scale);
+    DEFINE_VAR(origin);
+    enumError err = ScanVectorExprSI(&si,&scale,1.0,1);
+    DASSERT( scale.mode == VAR_VECTOR );
+    if ( !err && NextCharSI(&si,false) == '@' )
+    {
+	sf->ptr++;
+	err = ScanVectorExprSI(&si,&origin,0.0,1);
+	DASSERT( origin.mode == VAR_VECTOR );
+    }
+    else
+    {
+	origin.x = origin.y = origin.z = 0.0;
+	origin.mode = VAR_VECTOR;
+    }
+
+    CheckEolSI(&si);
+    ResetSI(&si);
+
+    if (!err)
+	SetScaleMatrixD(&opt_transform,&scale.d3,&origin.d3);
+
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptRotate ( ccp arg )
+{
+     if (!arg)
+	return 0;
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),"Option --rot",0);
+    ScanFile_t *sf = si.cur_file;
+    DASSERT(sf);
+
+    DEFINE_VAR(rotate);
+    DEFINE_VAR(origin);
+    enumError err = ScanVectorExprSI(&si,&rotate,1.0,1);
+    DASSERT( rotate.mode == VAR_VECTOR );
+    if ( !err && NextCharSI(&si,false) == '@' )
+    {
+	sf->ptr++;
+	err = ScanVectorExprSI(&si,&origin,0.0,1);
+	DASSERT( origin.mode == VAR_VECTOR );
+    }
+    else
+    {
+	origin.x = origin.y = origin.z = 0.0;
+	origin.mode = VAR_VECTOR;
+    }
+
+    CheckEolSI(&si);
+    ResetSI(&si);
+
+    if (!err)
+    {
+	SetRotateMatrixD(&opt_transform,0,rotate.x,0.0,&origin.d3);
+	SetRotateMatrixD(&opt_transform,1,rotate.y,0.0,&origin.d3);
+	SetRotateMatrixD(&opt_transform,2,rotate.z,0.0,&origin.d3);
+    }
+
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptXRotate ( uint xyz, ccp arg )
+{
+    DASSERT(xyz<3);
+    if ( !arg || xyz >= 3 )
+	return 0;
+
+    static ccp tab_info[] = { "Option --xrot", "Option --yrot", "Option --zrot" };
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),tab_info[xyz],0);
+    ScanFile_t *sf = si.cur_file;
+    DASSERT(sf);
+
+    DEFINE_VAR(temp);
+    enumError err = ScanExprSI(&si,&temp);
+    double degree = GetDoubleV(&temp);
+
+    if ( !err && NextCharSI(&si,false) == '@' )
+    {
+	sf->ptr++;
+	err = ScanVectorExprSI(&si,&temp,0.0,xyz);
+	DASSERT( temp.mode == VAR_VECTOR );
+    }
+    else
+    {
+	temp.x = temp.y = temp.z = 0.0;
+	temp.mode = VAR_VECTOR;
+    }
+    CheckEolSI(&si);
+    ResetSI(&si);
+
+    if (!err)
+	SetRotateMatrixD(&opt_transform,xyz,degree,0.0,&temp.d3);
+
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptAScale ( ccp arg )
+{
+     if (!arg)
+	return 0;
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),"Option --ascale",0);
+    ScanFile_t *sf = si.cur_file;
+    DASSERT(sf);
+
+    DEFINE_VAR(temp);
+    enumError err = ScanExprSI(&si,&temp);
+    if (err)
+	goto abort;
+    const double scale = GetDoubleV(&temp);
+    if ( fabs(scale) < NULL_EPSILON )
+    {
+	err = ERROR0(ERR_SEMANTIC,
+			"Option --ascale: Scale factor too small: %s\n",arg);
+	goto abort;
+    }
+
+    err = CheckWarnSI(&si,'@',err);
+    if (err)
+	goto abort;
+    ccp arg_vector =sf->ptr;
+
+    DEFINE_VAR(dir);
+    err = ScanVectorExprSI(&si,&dir,0.0,1);
+    if (err)
+	goto abort;
+    DASSERT( dir.mode == VAR_VECTOR );
+
+    const double dir_len = Length3(dir);
+    if ( dir_len < NULL_EPSILON )
+    {
+	err = ERROR0(ERR_SEMANTIC,
+			"Option --ascale: Vector is too small: %s\n",arg_vector);
+	goto abort;
+    }
+    err = CheckEolSI(&si);
+    if (err)
+	goto abort;
+
+    //--- valid axis scale entered
+
+    ascale_valid = fabs(scale) >= NULL_EPSILON && fabs(scale-10.0) >= NULL_EPSILON;
+    ascale = scale;
+    Div3f(ascale_dir,dir,dir_len);
+    NextTransformation(false);
+
+ abort:
+    ResetSI(&si);
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptARotate ( ccp arg )
+{
+     if (!arg)
+	return 0;
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),"Option --arot",0);
+    ScanFile_t *sf = si.cur_file;
+    DASSERT(sf);
+
+    DEFINE_VAR(temp);
+    enumError err = ScanExprSI(&si,&temp);
+    if (err)
+	goto abort;
+    const double degree = fmod(GetDoubleV(&temp)+180.0,360.0)-180.0;
+
+    err = CheckWarnSI(&si,'@',err);
+    if (err)
+	goto abort;
+    ccp arg_vector =sf->ptr;
+
+    DEFINE_VAR(p1);
+    DEFINE_VAR(p2);
+    err = ScanVectorExprSI(&si,&p2,0.0,1);
+    if (err)
+	goto abort;
+    DASSERT( p2.mode == VAR_VECTOR );
+
+    if ( NextCharSI(&si,false) == '@' )
+    {
+	p1 = p2;
+	sf->ptr++;
+	err = ScanVectorExprSI(&si,&p2,0.0,1);
+	if (err)
+	    goto abort;
+	DASSERT( p2.mode == VAR_VECTOR );
+    }
+    else
+	p1.x = p1.y = p1.z = 0.0;
+
+    double3 delta;
+    Sub3(delta,p1,p2);
+    const double len = Length3(delta);
+    if ( len < NULL_EPSILON )
+    {
+	err = ERROR0(ERR_SEMANTIC,
+			"Option --arot: Points to near: %s\n",arg_vector);
+	goto abort;
+    }
+    err = CheckEolSI(&si);
+    if (err)
+	goto abort;
+
+    //--- valid axis rotation entered
+
+    arot_valid = true; //fabs(degree) >= MIN_DEGREE;
+    arot_deg = degree;
+    arot1 = p1.d3;
+    arot2 = p2.d3;
+    NextTransformation(false);
+
+ abort:
+    ResetSI(&si);
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptYPos ( ccp arg )
+{
+    if (!arg)
+	return 0;
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),"Options --ypos",0);
+
+    DEFINE_VAR(temp);
+    enumError err = ScanExprSI(&si,&temp);
+    yposition_valid = temp.mode != VAR_UNSET;
+    yposition = GetYDoubleV(&temp);
+    CheckEolSI(&si);
+    ResetSI(&si);
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptXSS ( uint xyz, ccp arg )
+{
+    DASSERT( xyz < 3 );
+    if ( !arg || xyz >= 3 )
+	return 0;
+
+    static ccp tab_info[] = { "Option --xss", "Option --yss", "Option --zss" };
+    ccp opt_info = tab_info[xyz];
+
+    ScanInfo_t si;
+    InitializeSI(&si,arg,strlen(arg),opt_info,0);
+    ScanFile_t *sf = si.cur_file;
+    DASSERT(sf);
+    sf->disable_comma++;
+
+    DEFINE_VAR(temp);
+    enumError err = ScanExprSI(&si,&temp);
+    err = CheckWarnSI(&si,',',err);
+    if (err)
+	goto abort;
+    double old1 = GetDoubleV(&temp);
+
+    err = ScanExprSI(&si,&temp);
+    err = CheckWarnSI(&si,',',err);
+    if (err)
+	goto abort;
+    double new1 = GetDoubleV(&temp);
+
+    err = ScanExprSI(&si,&temp);
+    err = CheckWarnSI(&si,',',err);
+    if (err)
+	goto abort;
+    double old2 = GetDoubleV(&temp);
+
+    err = ScanExprSI(&si,&temp);
+    if (err)
+	goto abort;
+    double new2 = GetDoubleV(&temp);
+
+    CheckEolSI(&si);
+
+    if ( fabs(old1-old2) < 1e-6 )
+    {
+	err = ERROR0(ERR_SEMANTIC,
+		"%s: 'old' values are to close together, delta=%6.3e",
+		opt_info, fabs(old1-old2) );
+	goto abort;
+    }
+
+    SetScaleShiftMatrixD(&opt_transform,xyz,old1,new1,old2,new2);
+
+ abort:
+    ResetSI(&si);
+    return err != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////		    Transformation Script		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp		 tfs_filename = 0;
+static u8		*tfs_data = 0;
+static uint		 tfs_size = 0;
+static ScanInfo_t	 tfs_si = {0};
+static ScanMacro_t	*tfs_macro = 0;
+static uint		 tfs_index = 0;
+
+#if HAVE_PRINT
+    static uint		 tfs_count_f = 0;
+    static uint		 tfs_count_d = 0;
+#endif
+
+bool tform_script_enabled = false;
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptTformScript ( ccp arg )
+{
+    tfs_filename = arg;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanTformScript()
+{
+    tfs_macro = 0;
+    tform_script_enabled = false;
+
+    if ( !tfs_filename || !*tfs_filename )
+	return ERR_NOTHING_TO_DO;
+
+    enumError err = OpenReadFILE(tfs_filename,0,false,&tfs_data,&tfs_size,0,0);
+    if ( err || !tfs_data || !tfs_size )
+    {
+     abort:
+	FREE(tfs_data);
+	tfs_data = 0;
+	tfs_size = 0;
+	tfs_filename = 0;
+	return err;
+    }
+
+    InitializeSI(&tfs_si,(ccp)tfs_data,tfs_size,tfs_filename,REVISION_NUM);
+    while (NextLineSI(&tfs_si,false,true))
+	;  //--- scan source
+
+    const Var_t *vp = FindVarMap(&tfs_si.macro,"TRANSFORM",0);
+    if ( !vp || !vp->macro )
+    {
+	ResetSI(&tfs_si);
+	err = ERR_NOTHING_TO_DO;
+	goto abort;
+    }
+
+    tfs_macro = vp->macro;
+    PRINT("MACRO TRANSFORM found\n");
+    tform_script_enabled = true;
+    transform_active = true;
+    have_patch_count++;
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static bool tfs_call_macro
+(
+    const ScanMacro_t	*macro,		// macro to call
+    uint		dimension	// '2' for a 2D and '3' for a 3D vector
+)
+{
+    DASSERT(tform_script_enabled);
+    DASSERT(macro);
+
+
+    //--- define local variables, '$P' is already defined
+
+    Var_t *var = InsertVarMap(&tfs_si.lvar,"$D",false,0,0);
+    DASSERT(var);
+    var->mode = VAR_INT;
+    var->i = dimension;
+
+    var = InsertVarMap(&tfs_si.lvar,"$I",false,0,0);
+    DASSERT(var);
+    var->mode = VAR_INT;
+    var->i = tfs_index++;
+
+
+    //--- setup macro
+
+    ScanFile_t *sf = tfs_si.cur_file;
+    DASSERT(sf);
+
+    const uint saved_n_files = tfs_si.n_files;
+    tfs_si.n_files = 0;
+    tfs_si.cur_file = &empty_scan_file;
+    tfs_si.last_result.mode = VAR_UNSET;
+
+    ScanFile_t *newsf = AddSF( &tfs_si, macro->data, macro->data_size,
+				macro->src_name, REVISION_NUM, 0 );
+    DASSERT(newsf);
+
+    newsf->active_macro = macro;
+    newsf->line = macro->line0;
+
+    //--- scan source
+
+    while (NextLineSI(&tfs_si,false,true))
+	;
+
+    //--- close source
+
+    while (DropSF(&tfs_si))
+	;
+    tfs_si.cur_file = sf;
+    tfs_si.n_files = saved_n_files;
+
+    //--- terminate
+
+    return tfs_si.last_result.mode == VAR_VECTOR;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool ScanTformBegin()
+{
+    if (!tform_script_enabled)
+	return false;
+    DASSERT(tfs_macro);
+
+    ClearVarMap(&tfs_si.lvar);
+    //ClearVarMap(&tfs_si.gvar);
+
+    const Var_t *vp = FindVarMap(&tfs_si.macro,"BEGIN",0);
+    if ( vp && vp->macro )
+    {
+	tfs_index = -1;
+	tfs_call_macro(vp->macro,0);
+    }
+
+    tfs_index = 0;
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool TformScriptEnd()
+{
+    if (!tform_script_enabled)
+	return false;
+
+    PRINT("### TFROM-STAT:  %llu + %llu\n",
+		N_MatrixD_forward, N_MatrixD_inverse );
+    PRINT("### SCRIPT-STAT: %u | %u + %u = %u\n",
+		tfs_index,
+		tfs_count_f, tfs_count_d, tfs_count_f + tfs_count_d );
+
+    const Var_t *vp = FindVarMap(&tfs_si.macro,"END",0);
+    if ( vp && vp->macro )
+    {
+	tfs_call_macro(vp->macro,0);
+	tfs_index--;
+    }
+
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError TformScriptCallF
+(
+    uint	dimension,	// '2' for a 2D and '3' for a 3D vector
+    float3	*v,		// pointer to list of 3D vectors
+    int		n,		// number of 3D vectors
+    uint	off		// if n>1: offset from one to next vector
+)
+{
+    DASSERT(tform_script_enabled);
+    DASSERT(tfs_macro);
+
+    if ( n <= 0 || !tfs_macro )
+	return ERR_NOTHING_TO_DO;
+    DASSERT(v);
+
+   #if HAVE_PRINT
+    tfs_count_f += n;
+   #endif
+
+    for(;;)
+    {
+	ClearVarMap(&tfs_si.lvar);
+	Var_t *var = InsertVarMap(&tfs_si.lvar,"$P",false,0,0);
+	DASSERT(var);
+	var->mode = VAR_VECTOR;
+	var->x = v->x;
+	var->y = v->y;
+	var->z = v->z;
+
+	if (tfs_call_macro(tfs_macro,dimension))
+	{
+	    v->x = tfs_si.last_result.x;
+	    v->y = tfs_si.last_result.y;
+	    v->z = tfs_si.last_result.z;
+	}
+
+	if (!--n)
+	    return ERR_OK;
+	v = (typeof(v))( (u8*)v + off );
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError TformScriptCallD
+(
+    uint	dimension,	// '2' for a 2D and '3' for a 3D vector
+    double3	*v,		// pointer to list of 3D vectors
+    int		n,		// number of 3D vectors
+    uint	off		// if n>1: offset from one to next vector
+)
+{
+    DASSERT(tform_script_enabled);
+    DASSERT(tfs_macro);
+
+    if ( n <= 0 || !tfs_macro )
+	return ERR_NOTHING_TO_DO;
+    DASSERT(v);
+
+   #if HAVE_PRINT
+    tfs_count_d += n;
+   #endif
+
+    for(;;)
+    {
+	ClearVarMap(&tfs_si.lvar);
+	Var_t *var = InsertVarMap(&tfs_si.lvar,"$P",false,0,0);
+	DASSERT(var);
+	var->mode = VAR_VECTOR;
+	var->x = v->x;
+	var->y = v->y;
+	var->z = v->z;
+
+	if (tfs_call_macro(tfs_macro,dimension))
+	{
+	    v->x = tfs_si.last_result.x;
+	    v->y = tfs_si.last_result.y;
+	    v->z = tfs_si.last_result.z;
+	}
+
+	if (!--n)
+	    return ERR_OK;
+	v = (typeof(v))( (u8*)v + off );
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		    Transformation Setup		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint	force_transform		= 0;		// bit 0: force tform even if not needed
+						// bit 1: ignore it
+
+MatrixD_t opt_transform		= {0};		// current transform values
+MatrixD_t transform_list[N_TRANSFORM] = {{0}};	// list with stored tforms
+
+uint	n_transform_list	= 0;		// number of elements in list
+bool    transform_active	= false;	// true: transformation active
+int	disable_transformation	= 0;		// >0: transformation is temporary disabled
+
+double  yposition		= 0.0;		// defined y position
+bool    yposition_valid		= false;	// 'yposition' is valid
+
+bool	ascale_valid		= false;	// true: --ascale defined
+double	ascale			= 0.0;		// scaling factor
+double3	ascale_dir;				// scaling direction (vector)
+
+bool	arot_valid		= false;	// true: --arot defined
+double	arot_deg		= 0.0;		// angle of arot in degree
+double3	arot1, arot2;				// points to define rotation axis
+
+uint	mdl_switched_to_vertex	= 0;		// 0: default
+						// 1: switch to 'VERTEX' needed
+						// 2: MDL_MODE switched to 'VERTEX'
+						// 3: '2' and message printed
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetTransformation() // reset all transformation steps
+{
+    if (transform_active)
+    {
+	transform_active = false;
+	have_patch_count--;
+    }
+
+    n_transform_list = 0;
+    InitializeMatrixD(&opt_transform);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int NextTransformation ( bool for_close ) // enter next transformation step
+{
+    CalcMatrixD(&opt_transform,true);
+    if ( opt_transform.transform_enabled || force_transform == 1 && for_close )
+    {
+	force_transform |= 2;
+	if ( n_transform_list >= N_TRANSFORM-!for_close )
+	{
+	    static bool err_done = false;
+	    if (!err_done)
+	    {
+		err_done = true;
+		ERROR0(ERR_SEMANTIC,
+			"Maximum number of --next (%u) already reached.\n",
+			N_TRANSFORM-1 );
+	    }
+	    return 1;
+	}
+
+	memcpy( transform_list + n_transform_list,
+		&opt_transform,
+		sizeof(*transform_list) );
+
+	n_transform_list++;
+	PRINT("--next: level %u/%u\n",n_transform_list,N_TRANSFORM);
+    }
+
+    InitializeMatrixD(&opt_transform);
+
+
+    //--- special: axis scaling
+
+    if (ascale_valid)
+    {
+	ascale_valid = false;
+	SetAScaleMatrixD(&opt_transform,ascale,&ascale_dir);
+	NextTransformation(for_close);
+    }
+
+
+    //--- special: axis rotation
+
+    if (arot_valid)
+    {
+	arot_valid = false;
+	SetARotateMatrixD(&opt_transform,arot_deg,0.0,&arot1,&arot2);
+	NextTransformation(for_close);
+    }
+
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void CloseTransformation() // close transformation input
+{
+    NextTransformation(true);
+    transform_active = n_transform_list > 0;
+
+    if (!transform_active)
+	InitializeMatrixD(&opt_transform);
+    else
+    {
+	have_patch_count++;
+	memcpy( &opt_transform, transform_list, sizeof(opt_transform) );
+
+	uint i;
+	for  ( i = 1; i < n_transform_list; i++ )
+	    MultiplyMatrixD(&opt_transform,0,transform_list+i,0);
+    }
+    CalcMatrixD(&opt_transform,true);
+    mdl_switched_to_vertex = !opt_transform.norm_valid;
+
+    ScanTformScript();
+
+    if (transform_active)
+	PATCH_ACTION_LOG("Setup","-","%u transformation step%s defined.\n",
+		n_transform_list, n_transform_list == 1 ? "" : "s" );
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void DumpTransformationOpt()
+{
+    if (have_set_scale)
+	printf("  set-scale:        %11.3f %11.3f %11.3f\n",
+		set_scale.x, set_scale.y, set_scale.z );
+
+    if (have_set_rot)
+	printf("  set-rot:          %11.3f %11.3f %11.3f\n",
+		set_rot.x, set_rot.y, set_rot.z );
+
+    if (have_set_value)
+	printf(	"  set-xyz-min:      %11.3f %11.3f %11.3f\n"
+		"  set-xyz-max:      %11.3f %11.3f %11.3f\n",
+		set_value_min.x, set_value_min.y, set_value_min.z,
+		set_value_max.x, set_value_max.y, set_value_max.z );
+
+    if ( ascale != 0.0 )
+    {
+	printf(	"  last axis-scale:  %11.3f @ %11.3f %11.3f %11.3f\n",
+		ascale,
+		ascale_dir.x, ascale_dir.y, ascale_dir.z );
+    }
+
+    if ( arot_deg != 0.0 )
+    {
+	printf(	"  last axis-rot:    %11.3f @ %11.3f %11.3f %11.3f\n"
+		"%33s %11.3f %11.3f %11.3f\n",
+		arot_deg, arot1.x, arot1.y, arot1.z,
+		"->",     arot2.x, arot2.y, arot2.z );
+    }
+
+    if (!transform_active)
+	return;
+
+    if ( n_transform_list > 1 )
+    {
+	uint i;
+	for ( i = 0; i < n_transform_list; i++ )
+	{
+	    printf("\nTransformation step %u/%u:\n",i+1,n_transform_list);
+	    if ( verbose > 0 )
+		PrintMatrixD(stdout,2,0,transform_list+i,~0,0x1f);
+	    else
+		PrintMatrixD(stdout,2,0,transform_list,1,3);
+	}
+	printf("\nFinal Transformation:\n");
+    }
+    else
+	printf("\nTransformation:\n");
+
+    if ( verbose > 0 )
+	PrintMatrixD(stdout,2,0,&opt_transform,~0,0x1f);
+    else
+	PrintMatrixD(stdout,2,0,&opt_transform,1,3);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+double3 TransformD3( uint mode, double3 *val )	// transformate a single vector
+{
+    DASSERT(val);
+
+    uint i;
+    double3 res;
+    switch (mode)
+    {
+	case 1:
+	    res = *val;
+	    for ( i = 0; i < n_transform_list; i++ )
+		res = BaseTransformD3MatrixD(transform_list+i,&res);
+	    break;
+
+	case 2:
+	    res = *val;
+	    for ( i = 0; i < n_transform_list; i++ )
+		res = NormTransformD3MatrixD(transform_list+i,&res);
+	    break;
+
+	case 3:
+	    res = *val;
+	    for ( i = 0; i < n_transform_list; i++ )
+		res = TransformD3MatrixD(transform_list+i,&res);
+	    break;
+
+	default:
+	    res = TransformD3MatrixD(&opt_transform,val);
+	    break;
+    }
+    if (tform_script_enabled)
+	TformScriptCallD(3,&res,1,0);
+    return res;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			Transformations			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void TransformPosFloat2D
+(
+    float	*v,	// pointer to list of 2D vectors
+    int		n,	// number of 2D vectors
+    uint	off	// if n>1: offset from one to next vector
+)
+{
+    DASSERT(v);
+    DASSERT(n>0);
+    DASSERT( n <= 1 || off >= 2 * sizeof(*v) );
+
+    CalcNormMatrixD(&opt_transform); // calc 'norm_pos2d'
+    const double ypos = yposition_valid ? yposition : opt_transform.norm_pos2d.y;
+
+    off -= 2 * sizeof(*v);
+    while ( n-- > 0 )
+    {
+	float3 f;
+	f.x = v[0];
+	f.y = ypos;
+	f.z = v[1];
+	f = TransformF3MatrixD(&opt_transform,&f);
+	if (tform_script_enabled)
+	    TformScriptCallF(2,&f,1,0);
+	*v++ = f.x;
+	*v++ = f.z;
+	v = (float*)( (u8*)v + off );
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void TransformPosDouble2D
+(
+    double	*v,	// pointer to list of 2D vectors
+    int		n,	// number of 2D vectors
+    uint	off	// if n>1: offset from one to next vector
+)
+{
+    DASSERT(v);
+    DASSERT(n>0);
+    DASSERT( n <= 1 || off >= 2 * sizeof(*v) );
+
+    CalcNormMatrixD(&opt_transform); // calc 'norm_pos2d'
+    const double ypos = yposition_valid ? yposition : opt_transform.norm_pos2d.y;
+
+    off -= 2 * sizeof(*v);
+    while ( n-- > 0 )
+    {
+	double3 d;
+	d.x = v[0];
+	d.y = ypos;
+	d.z = v[1];
+	d = TransformD3MatrixD(&opt_transform,&d);
+	if (tform_script_enabled)
+	    TformScriptCallD(2,&d,1,0);
+	*v++ = d.x;
+	*v++ = d.z;
+	v = (double*)( (u8*)v + off );
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static bool IsNormValid()
+{
+    CalcNormMatrixD(&opt_transform);
+    if (opt_transform.norm_valid)
+	return true;
+
+    static bool done = false;
+    if ( !done && opt_transform.tmatrix_valid )
+    {
+	done = true;
+	ERROR0(ERR_WARNING,
+		"Because of the complex transformation matrix, it is impossible"
+		" to modify the scale and rotate vectors of different KMP sections;"
+		" the vectors keep unchanged. A manual correction is needed."
+		" The position vectors can always be transformed." );
+    }
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void TransformScaleFloat1D
+(
+    float	*v,	// pointer to list of 3D vectors
+    int		n,	// number of 2D vectors
+    uint	off	// if n>1: offset from one to next vector
+)
+{
+    DASSERT(v);
+    DASSERT(n>0);
+    DASSERT( n <= 1 || off >= sizeof(*v) );
+
+    if ( IsNormValid() && opt_transform.scale_enabled )
+    {
+	// only for KMP ENPT+ITPT scales:
+	const float scale_1d = ( fabs(opt_transform.norm_scale.x)
+			       + fabs(opt_transform.norm_scale.z) ) / 2;
+
+	while ( n-- > 0 )
+	{
+	    *v *= scale_1d;
+	    v = (float*)( (u8*)v + off );
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void TransformScaleFloat3D
+(
+    float	*v,	// pointer to list of 3D vectors
+    int		n,	// number of 2D vectors
+    uint	off	// if n>1: offset from one to next vector
+)
+{
+    DASSERT(v);
+    DASSERT(n>0);
+    DASSERT( n <= 1 || off >= 3 * sizeof(*v) );
+
+    if ( IsNormValid() && opt_transform.scale_enabled )
+    {
+	const double3 *scale = &opt_transform.norm_scale;
+
+	while ( n-- > 0 )
+	{
+	    v[0] *= scale->x;
+	    v[1] *= scale->y;
+	    v[2] *= scale->z;
+	    v = (float*)( (u8*)v + off );
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void TransformScaleDouble3D
+(
+    double	*v,	// pointer to list of 3D vectors
+    int		n,	// number of 3D vectors
+    uint	off	// if n>1: offset from one to next vector
+)
+{
+    DASSERT(v);
+    DASSERT(n>0);
+    DASSERT( n <= 1 || off >= 3 * sizeof(*v) );
+
+    if ( IsNormValid() && opt_transform.scale_enabled )
+    {
+	const double3 *scale = &opt_transform.norm_scale;
+	while ( n-- > 0 )
+	{
+	    v[0] *= scale->x;
+	    v[1] *= scale->y;
+	    v[2] *= scale->z;
+	    v = (double*)( (u8*)v + off );
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void TransformRotFloat3D
+(
+    float	*v,	// pointer to list of 3D vectors
+    int		n,	// number of 2D vectors
+    uint	off	// if n>1: offset from one to next vector
+)
+{
+    DASSERT(v);
+    DASSERT(n>0);
+    DASSERT( n <= 1 || off >= 3 * sizeof(*v) );
+
+    if ( IsNormValid() && opt_transform.rotate_enabled )
+    {
+	const double3 *rotate = &opt_transform.norm_rotate_deg;
+
+	while ( n-- > 0 )
+	{
+	    v[0] = fmod( v[0] + rotate->x, 360.0 );
+	    v[1] = fmod( v[1] + rotate->y, 360.0 );
+	    v[2] = fmod( v[2] + rotate->z, 360.0 );
+	    v = (float*)( (u8*)v + off );
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void TransformRotDouble3D
+(
+    double	*v,	// pointer to list of 3D vectors
+    int		n,	// number of 3D vectors
+    uint	off	// if n>1: offset from one to next vector
+)
+{
+    DASSERT(v);
+    DASSERT(n>0);
+    DASSERT( n <= 1 || off >= 3 * sizeof(*v) );
+
+    if ( IsNormValid() && opt_transform.rotate_enabled )
+    {
+	const double3 *rotate = &opt_transform.norm_rotate_deg;
+
+	while ( n-- > 0 )
+	{
+	    v[0] = fmod( v[0] + rotate->x, 360.0 );
+	    v[1] = fmod( v[1] + rotate->y, 360.0 );
+	    v[2] = fmod( v[2] + rotate->z, 360.0 );
+	    v = (double*)( (u8*)v + off );
+	}
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command matrix			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError cmd_matrix()
+{
+    enumError stat = ERR_OK;
+    const uint print_mode = verbose < -1 ? 0 : verbose < 0 ? 1 : 2;
+
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	ScanInfo_t si;
+	InitializeSI(&si,param->arg,strlen(param->arg),"TEST",0);
+	DEFINE_VAR(val);
+	const enumError err = ScanVectorExprSI(&si,&val,0.0,1);
+	if (!err)
+	    TestMatrix(&val.d3,print_mode,true);
+    }
+
+    if ( verbose >= 0 )
+	PrintTestMatrix(true);
+
+    return stat;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool TestMatrix
+(
+    // returns false on error
+
+    double3	*val,		// NULL or value to test
+    uint	print_mode,	// 0: silent
+				// 1: print vectors on error
+				// 2: print vectors always
+    bool	print_matrix	// true && if vector shall print:
+				//   print matrix before, but only the first time
+)
+{
+    if (!val)
+	return true;
+
+    enum { max_mode = 4 };
+
+    uint mode;
+    double3 inv, tr[max_mode];
+    for ( mode = 0; mode < max_mode; mode++ )
+	tr[mode] = TransformD3(mode,val);
+    inv = InvTransformD3MatrixD(&opt_transform,tr);
+
+    const double null_epsilon	  = 1e-7;
+    const double diff_epsilon     = 1e-6;
+    bool inv_ok = IsEqualD3( &inv,  val, null_epsilon, diff_epsilon );
+
+    bool all_ok = inv_ok, tr_ok[max_mode];
+    for ( mode = 1; mode < max_mode; mode++ )
+    {
+	tr_ok[mode] = IsEqualD3(tr,tr+mode,null_epsilon,diff_epsilon);
+	if (!tr_ok[mode])
+	    all_ok = false;
+    }
+
+    if ( print_mode > all_ok )
+    {
+	if (print_matrix)
+	    PrintTestMatrix(true);
+
+	printf(" Base vector:    %11.3f %11.3f %11.3f\n",
+		val->x, val->y, val->z );
+	if ( verbose > 0 || !inv_ok )
+	    printf(" T.form+Inverse: %11.3f %11.3f %11.3f [%d]\n",
+		inv.x, inv.y, inv.z, inv_ok );
+	printf(" Transformation: %11.3f %11.3f %11.3f\n",
+		tr->x, tr->y, tr->z );
+	for ( mode = 1; mode < max_mode; mode++ )
+	    if ( verbose > 0 || !tr_ok[mode] )
+		printf(" Transform[%u]:   %11.3f %11.3f %11.3f [%d]\n",
+		    mode, tr[mode].x, tr[mode].y, tr[mode].z, tr_ok[mode] );
+	printf("%.57s\n",Minus300);
+    }
+    return all_ok;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool PrintTestMatrix ( bool print_sep )
+{
+    static uint seq_num = ~0;
+    if ( seq_num == opt_transform.sequence_number )
+	return false;
+    seq_num = opt_transform.sequence_number;
+    putchar('\n');
+
+    static char xyz[8][4] = { "---", "x--", "-y-", "xy-", "--z", "x-z", "-yz", "xyz" };
+    static char use[4] = "-us?";
+
+    uint pmode_step, pmode_final;
+    if ( brief_count > 1 )
+    {
+	pmode_step  = 0x08;
+	pmode_final = 0x08;
+    }
+    else if ( brief_count > 0 )
+    {
+	pmode_step  = 0x08;
+	pmode_final = 0x16;
+    }
+    else if ( long_count > 1 )
+    {
+	pmode_step  = 0x1f;
+	pmode_final = 0x1e;
+    }
+    else if ( long_count > 0 )
+    {
+	pmode_step  = 0x17;
+	pmode_final = 0x1e;
+    }
+    else
+    {
+	pmode_step  = 0x17;
+	pmode_final = n_transform_list > 1 ? 0x16 : 0x1f;
+    }
+
+    ccp sep;
+    static char sep_eq[] = "========================================"
+			   "========================================";
+
+    if ( n_transform_list <= 1 )
+    {
+	pmode_final |= pmode_step;
+	sep = Minus300;
+    }
+    else
+    {
+	sep = sep_eq;
+	uint i;
+	for ( i = 0; i < n_transform_list; i++ )
+	{
+	    MatrixD_t *t = transform_list+i;
+	    printf("--------------- transformation matrix %u/%u [%s,%s,%s,%c] ---------------\n",
+		i+1, n_transform_list,
+		xyz[t->scale_enabled&7],
+		xyz[t->rotate_enabled&7],
+		xyz[t->translate_enabled&7],
+		use[t->use_matrix&3] );
+	    PrintMatrixD(stdout,0,0,t,0,pmode_step);
+	}
+    }
+
+    printf("%.14s Final transformation matrix [%s,%s,%s,%c] %.14s\n",
+	sep,
+	xyz[opt_transform.scale_enabled&7],
+	xyz[opt_transform.rotate_enabled&7],
+	xyz[opt_transform.translate_enabled&7],
+	use[opt_transform.use_matrix&3],
+	sep );
+    PrintMatrixD(stdout,0,0,&opt_transform,0,pmode_final);
+
+ #ifdef TEST
+    fputs("Vectors calculated by Matrix:\n",stdout);
+    MatrixD_t temp = opt_transform;
+    CalcVectorsMatrixD(&temp,true);
+    PrintMatrixD(stdout,0,0,&temp,0,2);
+ #endif
+
+    if (print_sep)
+	printf("%.73s\n",sep);
+
+    return true;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    END				///////////////
+///////////////////////////////////////////////////////////////////////////////
+