Multi dimensinal arrays for strings

[sravan-kumar--2]

hai
Im trying to form a multi dimensional string array.

1.if its in c++, char name[20][20]... like stuff will be worked.

but in MEL, I could find 'matrix' type only, that to for float.

is there any option for creating

multiDimensional string arrays in MEL?

1. Pyhton has Lists. they can be managed as MD Arrays..
   is MEL has the ability for Lists.?

please help me.

[thnkr]

1. No
2. No.

Why not forget about MEL and use Python instead?

[nowayfra]

You have to improvise a little bit...
This method is a little bit extravagant, but at the end you have a dynamically resizable matrix.
Therefore you will need two arrays, your string array and an int array - this will be your advanced index
for a 2-dimensional array. You also could make resizable n-dimensional arrays with some effords.

// now just create a random amount of poly spheres we will need to read some string values from (the face normals)
// we put their names into string $spheres[]

string $spheres[] = {};
int $numSpheres = rand(5,10);
for($i=0;$i<=$numSpheres;$i++)
{
    int $rand = rand(10,20); // for a random amount of faces per sphere
    $spheres = stringArrayCatenate($spheres, (`polySphere -r 1 -sx $rand -sy $rand -ax 0 1 0 -tx 1 -ch 0`));
};

// now we declare the "string matrix" and its custom index

string $stringMatrix[] = {};
int $rowStartAt[] = {};

// now we read the face normals of all spheres into the "string matrix"
// we want to be able to locate a certain face normal for a certain sphere later 
// we also set the int array values to the count at each spheres faces in the "string matrix"
// in this manner: row 0 begins at $stringMatrix[0], row 1 begins at $stringMatrix[x], row 2 at $stringMatrix[y] and so on
// so we set for row 0 $rowStartAt[0] = 0, for row 1 $rowStartAt[1] = x, for row 2 $rowStartAt[2] = y and so on

int $counter = 0;
for($i=0;$i<size $spheres;$i++)
{
    $rowStartAt[$i] = $counter;
    int $numFaces[] = polyEvaluate -face $spheres[$i];
    for($k=0;$k<$numFaces[0];$k++)
    {
        string $tmp[] = polyInfo -fn ($spheres[$i] + ".f[" + $k + "]");
        $stringMatrix[$counter] = $tmp[0];
        $counter++;        
    };
};
$rowStartAt[size $rowStartAt] = $counter; // we need to know where the last row ends, so we just add this element

// if we want to know the normal of face number 15 of the last created sphere
// its the same as we would want to know matrix[x][15]

int $highestIndex = size $spheres - 1;
print($stringMatrix[($rowStartAt[$highestIndex] + 15)] + "\n");

// now the face normal of face 0 of the last created sphere

print($stringMatrix[$rowStartAt[$highestIndex]] + "\n");

// now printing all face normals of sphere number 3 and 4

for($i=2;$i<=3;$i++) // because the index starts with 0
{
    for($k=$rowStartAt[$i];$k<$rowStartAt[($i + 1)];$k++)
    {
        print($spheres[$i] + " " + $stringMatrix[$k] + "\n");
    };
};

// now append a single element to the end of the row of a randomly choosen sphere

int $sphereNumber = rand(0,size($spheres));
print("choosen sphere: " + $spheres[$sphereNumber] + "\n");
string $element = "some_text";
stringArrayInsertAtIndex($rowStartAt[($sphereNumber + 1)], $stringMatrix, $element);

// now you have to update the index values of the sphere face count list after
// the randomly choosen sphere

for($i=0;$i<size $rowStartAt;$i++)
{
    if($i > $sphereNumber) $rowStartAt[$i] += 1;
};

// now getting the number of faces of a randomly choosen sphere
// would be the same as size $stringMatrix[$x][]

int $x = rand(0,size($spheres));
print("number of faces of " + $spheres[$x] + ": " + ($rowStartAt[$x + 1] - $rowStartAt[$x]) + "\n");

// Good luck

[sravan-kumar--2]

ThanQ very much.
I wil try it on.

[joojaa]

Well aside form the fact that a multidimensional array is easily done as a single dimensional array*. But honestly use python.

Bottom line is theres no such thing in mel since you could never do anything sane with sucha  construct anyway.

PS: theres no real reason to do this in mel, its not practical and nothing sane you could do with algoritmic code with mel anyway. Mel is not a storage form.

However mel can handle multidimrnsional arrays just as long as you store it in attribute.

*well since the computer oly really has nedimensional memory storage all otjer notations are in the ned one dimesnional at some point

[nowayfra]

Just for the proof of concept...

/*

The whole script relies on a globally declared string array and int array. You can NOT simply
declare additional string matrices and use them with the functions declared in THIS script.
If you need more matrices just copy the script and replace all occurences of the string
"stringMatrix" (in functions and variables) with "stringMatrix2" or so. Then call
the individual functions for the individual string matrix to get access. You don't need to
declare anything, just use the functions, the neccessary variables will be handled for you.
The size of the virtual rows and columns of the string matrix can of course not be specified,
they change dynamically during use and will be managed by the procedures.

---

FUNCTIONS:

// Bounds:

int stringMatrixGetRowSize(int $rowId)
    Returns the current amount of columns in a individual
    row regardless if the columns are empty ("") or filled.

int stringMatrixGetValidRowSize(int $rowId)                
    Returns the current amount of columns in a individual
    row holding values, means empty columns doesn't count.

int stringMatrixGetRowCount()                        
    Returns the actual amount of rows the string matrix
    contains regardless if they are empty or not.

int stringMatrixGetUpperBound()                        
    Returns the Id of the highest row containing valid
    strings. RETURNS -1 IF THE MATRIX IS EMPTY.

int stringMatrixGetValidSize()                        
    Returns the amount of non empty strings inside the
    whole matrix.

// Element Access:

string stringMatrixGetElement(int $rowId, int $colId)            
    Returns the string value at the given coordinate.

string[] stringMatrixGetRow(int $rowId)                    
    Returns all string values regardles if empty or not  
    of the given row as string array.

string[] stringMatrixGetValidRow(int $rowId)                
    Returns all non empty string values at the given row
    as string array.

string[] stringMatrixToStringArray()                    
    Returns all non empty strings inside the matrix as
    string array.

stringMatrixSetElement(string $element, int $rowId, int $colId)      
    Sets the given string value at the given coordinate of
    the matrix. This function creates new rows and columns
    if neccessary. Newly created rows in between are
    completely empty, created columns in between are
    filled with empty strings ("").

int stringMatrixAddElement(string $element, int $rowId)          
    Adds a given string value to the end of a given row
    and returns the column id at this entry. If a not
    already existing row is given, it will be created.

stringMatrixInsertElement(string $element, int $rowId, int $colId)    
    Inserts a given string value at the given coordinate.
    Rows will be created or expanded if neccessary.

int stringMatrixAddRow(string $rowStrArray[])                
    Adds a given string array as new row at the end of the
    matrix. Returns the row Id at this entry.

stringMatrixInsertRow(string $rowStrArray[], int $rowId)        
    Inserts a given string array as row at the given row Id.
    All rows at higher entries move up one step.

stringMatrixRemoveElement(int $rowId, int $colId)            
    If the given entry exists, it will be removed. Rows
    will be downsized but not deleted if they are empty
    after removal.

stringMatrixRemoveRow(int $rowId)                       
    If the given row exists, it will be removed. All rows
     at higher entries move down one step.

// Operations:

int stringMatrixDeflateRow(int $rowId)                    
    Sets the row bound to the last valid string in the
    given row and returns the new row size.

stringMatrixDeflate()                            
    Removes all unused rows above the current upper bound.

stringMatrixRemoveAll()                            
    Removes all the elements from the matrix.

*/

proc stringMatrixSetElement(string $element, int $rowId, int $colId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    if($rowId < `stringMatrixGetRowCount` && $colId < `stringMatrixGetRowSize $rowId`)
    {
        $stringMatrix[($customIndex[$rowId] + $colId)] = $element;
    }
    else stringMatrixInsertElement $element $rowId $colId;
};    

proc stringMatrixRemoveRow(int $rowId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    int $rowSize = stringMatrixGetRowSize $rowId;
    int $rowCount = stringMatrixGetRowCount;
    for($i=($rowSize - 1);$i>=0;$i--)
    {
        stringArrayRemoveAtIndex ($customIndex[$rowId] + $i) $stringMatrix;
    };
    int $newIndex[];
    for($i=0;$i<=$rowCount;$i++)
    {
        if($i <= $rowId) $newIndex[$i] = $customIndex[$i];
        else if($i < $rowCount) $newIndex[$i] = $customIndex[($i + 1)] - $rowSize;
    };
    $customIndex = $newIndex;
};

proc stringMatrixRemoveElement(int $rowId, int $colId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    if($rowId < `stringMatrixGetRowCount` && $colId < `stringMatrixGetRowSize $rowId`)
    {
        stringArrayRemoveAtIndex ($customIndex[$rowId] + $colId) $stringMatrix;
        for($i=($rowId + 1);$i<`size $customIndex`;$i++) $customIndex[$i] -= 1;
    };
};

proc stringMatrixRemoveAll()
{    
    global string $stringMatrix[];
    global int $customIndex[];
    clear $stringMatrix;
    $customIndex = {0};
};

proc stringMatrixInsertRow(string $rowStrArray[], int $rowId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    if(!size($customIndex)) stringMatrixRemoveAll();
    int $size = size $customIndex;
    int $numElements = size $rowStrArray;
    if(($size - 1) < $rowId)
    {
        int $count = $customIndex[($size - 1)];
        for($i=$size;$i<=$rowId;$i++) $customIndex[$i] = $count;
        for($element in $rowStrArray) $stringMatrix[size $stringMatrix] = $element;
        $customIndex[size $customIndex] = $count + $numElements;    
    }
    else
    {
        int $count = $customIndex[$rowId];
        for($i=0;$i<$numElements;$i++) stringArrayInsertAtIndex(($count + $i), $stringMatrix, $rowStrArray[$i]);
        int $newIndex[];
        for($i=0;$i<=size $customIndex;$i++)
        {
            if($i <= $rowId) $newIndex[$i] = $customIndex[$i];
            else $newIndex[$i] += $customIndex[($i - 1)] + $numElements;
        };
        $customIndex = $newIndex;
    };
};

proc stringMatrixInsertElement(string $element, int $rowId, int $colId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    int $rowSize = stringMatrixGetRowSize $rowId;
    int $size = size $customIndex;
    if($rowId >= stringMatrixGetRowCount())
    {
        string $tmp[];
        $tmp[$colId] = $element;
        stringMatrixInsertRow $tmp $rowId;
    }
    else if($colId >= $rowSize)
    {
        int $count = $colId - $rowSize;
        string $tmp[];
        $tmp[$count] = $element;
        for($i=0;$i<=$count;$i++) stringMatrixAddElement $tmp[$i] $rowId;
    }
    else
    {
        stringArrayInsertAtIndex(($customIndex[$rowId] + $colId), $stringMatrix, $element);
        for($i=0;$i<size $customIndex;$i++)
        {            
            if($i > $rowId) $customIndex[$i] += 1;
        };
    };
};

proc int stringMatrixGetValidSize()
{
    global string $stringMatrix[];
    int $counter = 0;
    for($i=0;$i<size $stringMatrix;$i++)
    {
        if($stringMatrix[$i] != "") $counter++;
    };
    return $counter;
};    

proc int stringMatrixGetValidRowSize(int $rowId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    int $rowSize = stringMatrixGetRowSize $rowId;
    int $counter = 0;
    for($i=0;$i<$rowSize;$i++)
    {
        if($stringMatrix[($customIndex[$rowId] + $i)] != "") $counter++;
    };
    return $counter;
};

proc string[] stringMatrixGetValidRow(int $rowId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    string $tmp[];
    for($i=$customIndex[$rowId];$i<$customIndex[($rowId + 1)];$i++)
    {
        if($stringMatrix[$i] != "") $tmp[size $tmp] = $stringMatrix[$i];
    };
    return $tmp;
};    

proc int stringMatrixGetUpperBound()
{
    global string $stringMatrix[];
    global int $customIndex[];
    int $matrixSize = size $stringMatrix;
    int $index = -1;
    for($i=($matrixSize - 1);$i>=0;$i--)
    {
        if($stringMatrix[$i] != "")
        {
            $index = $i;
            break;
        };
    };
    if($index > 0)
    {
        int $indexSize = size $customIndex;
        for($i=($indexSize - 1);$i>=0;$i--)
        {
            if($index >= $customIndex[$i])
            {
                return $i;
                break;
            };
        };
    }
    else return $index;
};

proc int stringMatrixGetRowSize(int $rowId)
{
    global int $customIndex[];
    if(!size($customIndex)) stringMatrixRemoveAll();
    return ($customIndex[($rowId + 1)] - $customIndex[$rowId]);
};

proc int stringMatrixGetRowCount()
{
    global int $customIndex[];
    if(!size($customIndex)) stringMatrixRemoveAll();
    return (size $customIndex - 1);
};

proc int stringMatrixGetRowCount()
{
    global int $customIndex[];
    if(!size($customIndex)) stringMatrixRemoveAll();
    return (size $customIndex - 1);
};

proc string stringMatrixGetElement(int $rowId, int $colId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    return $stringMatrix[($customIndex[$rowId] + $colId)];
};    

proc int stringMatrixDeflateRow(int $rowId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    int $rowSize = stringMatrixGetRowSize $rowId;
    for($i=($rowSize - 1);$i>=0;$i--)
    {
        if($stringMatrix[($customIndex[$rowId] + $i)] == "")
        {
            stringMatrixRemoveElement $rowId $i;
        }
        else break;
    };
    return stringMatrixGetRowSize $rowId;
};

proc stringMatrixDeflate()
{
    global string $stringMatrix[];
    global int $customIndex[];
    int $matrixSize = size $stringMatrix;
    int $validAt= -1;
    for($i=($matrixSize - 1);$i>=0;$i--)
    {
        if($stringMatrix[$i] != "")
        {
            $validAt = $i;
            break;
        };
    };
    if($validAt == -1) stringMatrixRemoveAll();
    else
    {
        int $validRow;
        int $switch = 1;
        int $newCustomIndex[];
        int $indexSize = size $customIndex;
        for($i=($indexSize - 1);$i>=0;$i--)
        {
            if($switch && $validAt >= $customIndex[$i])
            {
                $validRow = $i;
                $newCustomIndex[($i + 1)] = $customIndex[($i + 1)];
                $newCustomIndex[$i] = $customIndex[$i];
                $switch = 0;
            }
            else if(!$switch) $newCustomIndex[$i] = $customIndex[$i];            
        };
        int $rowSize = stringMatrixGetRowSize $validRow;
        string $newStringMatrix[];
        appendStringArray $newStringMatrix $stringMatrix ($customIndex[$validRow] + $rowSize);
        stringMatrixRemoveAll();
        $stringMatrix = $newStringMatrix;
        $customIndex = $newCustomIndex;
    };
};

proc int stringMatrixAddRow(string $rowStrArray[])
{
    global string $stringMatrix[];
    global int $customIndex[];
    if(!size($customIndex)) stringMatrixRemoveAll();
    for($element in $rowStrArray) $stringMatrix[size $stringMatrix] = $element;
    int $size = size $customIndex;
    $customIndex[$size] = $customIndex[($size - 1)] + size($rowStrArray);
    return ($size - 1);
};

proc int stringMatrixAddElement(string $element, int $rowId)
{
    global string $stringMatrix[];
    global int $customIndex[];
    if(!size($customIndex)) stringMatrixRemoveAll();
    if($rowId < (`size $customIndex` - 1))
    {
        stringArrayInsertAtIndex($customIndex[($rowId + 1)], $stringMatrix, $element);
        for($i=0;$i<`size $customIndex`;$i++)
        {
            if($i > $rowId) $customIndex[$i] += 1;
        };
        return ($customIndex[($rowId + 1)] - $customIndex[$rowId] - 1);
    }
    else
    {
        stringMatrixInsertRow {$element} $rowId;
        return 0;
    };    
};

proc string[] stringMatrixToStringArray()
{
    global string $stringMatrix[];
    string $tmp[];
    int $counter = 0;
    for($i=0;$i<size $stringMatrix;$i++)
    {
        if($stringMatrix[$i] != "") $tmp[$counter++] = $stringMatrix[$i];
    };
    return $tmp;
};    

// have a nice day

[sravan-kumar--2]

ok. thanQ.
I can handle lists in python.

If I want to

call a python script from mel, as well as call Mel Script from Python
how can it be.?

and where should I place the files together?

for eg,

# printPyhton.py
def printPython():
   print("Im in python");
   ## here I want to call
   ## printMEL();

this function should be called from

//printMel.mel
proc printMel()
{
   print(" Im in MEL");
   // here I want to call
   //  printPython();
}

Greateful to u.

[sravan-kumar--2]

thanq Very much.
but in case we use python,
can we call python functions from mel?

[joojaa]

in mel call python in python call mel.eval