Java MatFileReader.getMLArray方法代码示例

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
private void parseAnnotations(FileObject annotationFile) throws IOException {
	if (!annotationFile.exists()) {
		return;
	}

	final MatFileReader reader = new MatFileReader(annotationFile.getContent().getInputStream());

	final MLDouble boxes = (MLDouble) reader.getMLArray("box_coord");
	this.bounds = new Rectangle(
			(float) (double) boxes.getReal(2) - 1,
			(float) (double) boxes.getReal(0) - 1,
			(float) (boxes.getReal(3) - boxes.getReal(2)) - 1,
			(float) (boxes.getReal(1) - boxes.getReal(0)) - 1);

	final double[][] contourData = ((MLDouble) reader.getMLArray("obj_contour")).getArray();
	this.contour = new Polygon();
	for (int i = 0; i < contourData[0].length; i++) {
		contour.points.add(
				new Point2dImpl((float) contourData[0][i] + bounds.x - 1,
						(float) contourData[1][i] + bounds.y - 1)
				);
	}
	contour.close();
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
private void fillDataFields(MatFileReader reader) {
    root = (MLStructure) reader.getMLArray(rootKey);
    accX = getDoubleList(root, accXKey);
    accY = getDoubleList(root, accYKey);
    accZ = getDoubleList(root, accZKey);
    gpsSpeeds = getDoubleList(root, gpsSpeedKey);
    longitudes = getDoubleList(root, longitudeKey);
    latitudes = getDoubleList(root, latitudeKey);
    altitudes = getDoubleList(root, altitudeKey);
    indices = getIntList(root, indexKey);
    deviceIds = getIntList(root, deviceIdKey);
    years = getIntList(root, yearsKey);
    months = getIntList(root, monthsKey);
    days = getIntList(root, daysKey);
    hours = getIntList(root, hoursKey);
    minutes = getIntList(root, minutesKey);
    seconds = getIntList(root, secondsKey);
    gpsSpeeds = getDoubleList(root, gpsSpeedKey);
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
@Test
public void testMLCharUnicode() throws Exception
{
    //array name
    String name = "chararr";
    //file name in which array will be storred
    String fileName = "mlcharUTF.mat";
    File outFile = temp.newFile( fileName );
    //temp
    String valueS;

    //create MLChar array of a name "chararr" containig one
    //string value "dummy"
    MLChar mlChar = new MLChar(name, new String[] { "\u017C\u00F3\u0142w", "\u017C\u00F3\u0142i"} );
    MatFileWriter writer = new MatFileWriter();
    writer.write(outFile, Arrays.asList( (MLArray) mlChar ) );
    
    MatFileReader reader = new MatFileReader( outFile );
    MLChar mlChar2 = (MLChar) reader.getMLArray(name);

    assertEquals("\u017C\u00F3\u0142w", mlChar.getString(0) );
    assertEquals("\u017C\u00F3\u0142w", mlChar2.getString(0) );
    assertEquals("\u017C\u00F3\u0142i", mlChar2.getString(1) );        
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
/**
 * Regression bug
 * 
 * @throws Exception
 */
@Test 
public void testDoubleFromMatlabCreatedFile() throws Exception
{
    //array name
    String name = "arr";
    //file name in which array will be stored
    String fileName = "src/test/resources/matnativedouble.mat";

    //test column-packed vector
    double[] src = new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
    MLDouble mlDouble = new MLDouble( name, src, 3 );
    
    //read array form file
    MatFileReader mfr = new MatFileReader( fileName );
    MLArray mlArrayRetrived = mfr.getMLArray( name );
    
    //test if MLArray objects are equal
    assertEquals("Test if value red from file equals value stored", mlDouble, mlArrayRetrived);
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
/**
 * Regression bug.
 
 * <pre><code>
 * Matlab code:
 * >> arr = [1.1, 4.4; 2.2, 5.5; 3.3, 6.6];
 * >> save('matnativedouble2', arr);
 * </code></pre>
 * 
 * @throws IOException
 */
@Test 
public void testDoubleFromMatlabCreatedFile2() throws IOException
{
    //array name
    String name = "arr";
    //file name in which array will be stored
    String fileName = "src/test/resources/matnativedouble2.mat";

    //test column-packed vector
    double[] src = new double[] { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6 };
    MLDouble mlDouble = new MLDouble( name, src, 3 );
    
    //read array form file
    MatFileReader mfr = new MatFileReader( fileName );
    MLArray mlArrayRetrived = mfr.getMLArray( name );
    
    //test if MLArray objects are equal
    assertEquals("Test if value red from file equals value stored", mlDouble, mlArrayRetrived);
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
@Test 
public void testInt32() throws IOException
{
    //array name
    String name = "a";
    //file name in which array will be stored
    String fileName = "src/test/resources/int32.mat";

    //test column-packed vector
    int[] src = new int[] { 1, 2, 3, 4 };
    MLInt32 mlDouble = new MLInt32( name, src, 1 );
    
    //read array form file
    MatFileReader mfr = new MatFileReader( fileName );
    MLArray mlArrayRetrived = mfr.getMLArray( name );
    
    //test if MLArray objects are equal
    assertEquals("Test if value red from file equals value stored", mlDouble, mlArrayRetrived);
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException {
	final Map<Integer, String> database = readDatabase();

	final File outbase = new File("/Users/jon/Data/lfw/matlab-fvs/");

	for (int i = 1; i <= 128; i++) {
		final File chunk = new File(
				"/Users/jon/Downloads/data/lfw_aligned/SIFT_1pix_PCA64_GMM512/features/poolfv/1/", String.format(
						"feat_%d-v6.mat", i));

		System.out.println(chunk);

		final MatFileReader reader = new MatFileReader(chunk);
		final MLSingle feats = (MLSingle) reader.getMLArray("chunk");
		final MLDouble index = (MLDouble) reader.getMLArray("index");

		for (int j = 0; j < index.getN(); j++) {
			final int id = (int) (double) index.get(0, j);

			final File outfile = new File(outbase, database.get(id).replace(".jpg", ".bin"));
			outfile.getParentFile().mkdirs();

			final float[] vec = new float[feats.getM()];
			for (int k = 0; k < feats.getM(); k++) {
				vec[k] = feats.get(k, j);
			}

			final FloatFV fv = new FloatFV(vec);
			IOUtils.writeBinary(outfile, fv);
		}
	}

}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
private LinkedList<IndependentMeasurement> getMeasurements(MatFileReader matFileReader, String sourcePath) {
    LinkedList<IndependentMeasurement> measurements = new LinkedList<IndependentMeasurement>();

    try {
        MLStructure root = (MLStructure) matFileReader.getMLArray(rootKey);
        MLCell accX = (MLCell) root.getField(accXKey);
        MLCell accY = (MLCell) root.getField(accYKey);
        MLCell accZ = (MLCell) root.getField(accZKey);
        MLCell label = (MLCell) root.getField(labelKey);
        fillSampleProperyLists(root);

        int nOfSamples = (int) Math.round(((MLDouble) root.getField(nOfSamplesKey)).get(0));
        for (int i = 0; i < nOfSamples; i++) {
            double[] accXValues = getSampleRow(accX, i);
            double[] accYValues = getSampleRow(accY, i);
            double[] accZValues = getSampleRow(accZ, i);
            double[] labelValues = getSampleRow(label, i);
            List<IndependentMeasurement> newMeasurements = getMeasurementsFromSample(accXValues, accYValues, accZValues,
                    labelValues, i);
            measurements.addAll(newMeasurements);
        }
    } catch (NullPointerException e) {
        throwInvalidFormatException(sourcePath, e);
    }

    return measurements;
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
public void testBenchmarkDouble() throws Exception
    {
        final String fileName = "bb.mat";
        final String name = "bigdouble";
//        final int SIZE = 1000;    
        //System.out.println(14e6);
//        ByteBuffer.allocateDirect(1000000000);
        
        
//        MLDouble mlDouble = new MLDouble( name, new int[] {SIZE, SIZE} );
//        
//        for ( int i = 0; i < SIZE*SIZE; i++ )
//        {
//            mlDouble.set((double)i, i);
//        }
//        
//        
//        //write array to file
//        ArrayList<MLArray> list = new ArrayList<MLArray>();
//        list.add( mlDouble );
//        
//        //write arrays to file
//        new MatFileWriter( fileName, list );
//        
        //read array form file
        MatFileReader mfr = new MatFileReader( fileName );
        MLArray mlArrayRetrived = mfr.getMLArray( name );
//        
//        System.out.println( mlArrayRetrived );
//        System.out.println( mlArrayRetrived.contentToString() );
        
        //test if MLArray objects are equal
//        assertEquals("Test if value red from file equals value stored", mlDouble, mlArrayRetrived);
    }
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
@Test 
public void testBenchmarkUInt8() throws Exception
{
    final String fileName = "bigbyte.mat";
    final String name = "bigbyte";
    File outFile = temp.newFile( fileName );
    final int SIZE = 1024;    
    
    
    MLUInt8 mluint8 = new MLUInt8( name, new int[] { SIZE, SIZE } );
    
    //write array to file
    ArrayList<MLArray> list = new ArrayList<MLArray>();
    list.add( mluint8 );
    
    //write arrays to file
    new MatFileWriter( outFile, list );
    
    //read array form file
    MatFileReader mfr = new MatFileReader( outFile );
    MLArray mlArrayRetrived = mfr.getMLArray( name );
    
    final long start = System.nanoTime();
    for ( int i = 0; i < mlArrayRetrived.getSize(); i++ )
    {
        ((MLNumericArray<?>)mlArrayRetrived).get(i);
    }
    final long stop = System.nanoTime();
    System.out.println("--> " + (stop - start)/1e6 +  "[ns]");
           
    //test if MLArray objects are equal
    assertEquals("Test if value red from file equals value stored", mluint8, mlArrayRetrived);
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
/**
 * Test <code>MatFileFilter</code> options
 * @throws IOException 
 */
@Test
public void testMLStructure() throws IOException
{
    //array name
    //file name in which array will be storred
    String fileName = "mlstruct.mat";
    File outFile = temp.newFile( fileName );

    //test column-packed vector
    double[] src = new double[] { 1.3, 2.0, 3.0, 4.0, 5.0, 6.0 };
    
    //create 3x2 double matrix
    //[ 1.0 4.0 ;
    //  2.0 5.0 ;
    //  3.0 6.0 ]
    MLDouble mlDouble = new MLDouble( null, src, 3 );
    MLChar mlChar = new MLChar( null, "I am dummy" );
    
    
    MLStructure mlStruct = new MLStructure("str", new int[] {1,1} );
    mlStruct.setField("f1", mlDouble);
    mlStruct.setField("f2", mlChar);
    
    //write array to file
    ArrayList<MLArray> list = new ArrayList<MLArray>();
    list.add( mlStruct );
    
    //write arrays to file
    new MatFileWriter( outFile, list );
    
    //read array form file
    MatFileReader mfr = new MatFileReader( outFile );
    MLStructure mlArrayRetrived = (MLStructure)mfr.getMLArray( "str" );
    
    assertEquals(mlDouble, mlArrayRetrived.getField("f1") );
    assertEquals(mlChar, mlArrayRetrived.getField("f2") );
    

}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
@Test
public void testLogical() throws IOException
{
    String name = "bool";
    String fileName = "src/test/resources/logical.mat";
    
    MatFileReader reader = new MatFileReader( fileName );
    
    MLUInt8 mlArray = (MLUInt8) reader.getMLArray( name );
    assertEquals( 1, (int) mlArray.get(0) );
    assertEquals( 0, (int) mlArray.get(1) );
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
/**
 * Test <code>MatFileFilter</code> options
 * @throws IOException 
 */
@Test 
public void testMLCell() throws IOException
{
    //array name
    String name = "doublearr";
    String name2 = "name";
    //file name in which array will be storred
    String fileName = "mlcell.mat";
    File outFile = temp.newFile( fileName );

    //test column-packed vector
    double[] src = new double[] { 1.3, 2.0, 3.0, 4.0, 5.0, 6.0 };

    //create 3x2 double matrix
    //[ 1.0 4.0 ;
    //  2.0 5.0 ;
    //  3.0 6.0 ]
    MLDouble mlDouble = new MLDouble( name, src, 3 );
    MLChar mlChar = new MLChar( name2, "none" );
    
    
    MLCell mlCell = new MLCell("cl", new int[] {2,1} );
    mlCell.set(mlChar, 0);
    mlCell.set(mlDouble, 1);
    
    //write array to file
    ArrayList<MLArray> list = new ArrayList<MLArray>();
    list.add( mlCell );
    
    //write arrays to file
    new MatFileWriter( outFile, list );
    
    //read array form file
    MatFileReader mfr = new MatFileReader( outFile );
    MLCell mlArrayRetrived = (MLCell)mfr.getMLArray( "cl" );
    
    assertEquals(mlDouble, mlArrayRetrived.get(1) );
    assertEquals(mlChar, mlArrayRetrived.get(0) );
    

}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
/**
 * Tests <code>MLChar</code> reading and writing.
 * 
 * @throws IOException
 */
@Test 
public void testMLCharArray() throws IOException
{
    //array name
    String name = "chararr";
    //file name in which array will be storred
    String fileName = "mlchar.mat";
    File   outFile = temp.newFile( fileName );
    //temp
    String valueS;

    //create MLChar array of a name "chararr" containig one
    //string value "dummy"
    MLChar mlChar = new MLChar(name, "dummy");
    
    //get array name
    valueS = mlChar.getName();
    assertEquals("MLChar name getter", name, valueS);
    
    //get value of the first element
    valueS = mlChar.getString(0);
    assertEquals("MLChar value getter", "dummy", valueS);
    
    //write array to file
    ArrayList<MLArray> list = new ArrayList<MLArray>();
    list.add( mlChar );
    
    //write arrays to file
    new MatFileWriter( outFile, list );
    
    //read array form file
    MatFileReader mfr = new MatFileReader( outFile );
    MLArray mlCharRetrived = mfr.getMLArray( name );
    
    assertEquals("Test if value red from file equals value stored", mlChar, mlCharRetrived);
    
    //try to read non existent array
    mlCharRetrived = mfr.getMLArray( "nonexistent" );
    assertEquals("Test if non existent value is null", null, mlCharRetrived);
}
 

import com.jmatio.io.MatFileReader; //导入方法依赖的package包/类
/**
 * Tests <code>MLDouble</code> reading and writing.
 * 
 * @throws IOException
 */
@Test 
public void testMLDoubleArray() throws IOException
{
    //array name
    String name = "doublearr";
    //file name in which array will be storred
    String fileName = "mldouble.mat";
    File outFile = temp.newFile( fileName );
    
    //test column-packed vector
    double[] src = new double[] { 1.3, 2.0, 3.0, 4.0, 5.0, 6.0 };
    //test 2D array coresponding to test vector
    double[][] src2D = new double[][] { { 1.3, 4.0 },
                                        { 2.0, 5.0 },
                                        { 3.0, 6.0 }
                                    };

    //create 3x2 double matrix
    //[ 1.0 4.0 ;
    //  2.0 5.0 ;
    //  3.0 6.0 ]
    MLDouble mlDouble = new MLDouble( name, src, 3 );
    
    //write array to file
    ArrayList<MLArray> list = new ArrayList<MLArray>();
    list.add( mlDouble );
    
    //write arrays to file
    new MatFileWriter( outFile, list );
    
    //read array form file
    MatFileReader mfr = new MatFileReader( outFile );
    MLArray mlArrayRetrived = mfr.getMLArray( name );
    
    //System.out.println( mlDouble.contentToString() );
    //System.out.println( mlArrayRetrived.contentToString() );
    //test if MLArray objects are equal
    assertEquals("Test if value red from file equals value stored", mlDouble, mlArrayRetrived);
    
    //test if 2D array match
    for ( int i = 0; i < src2D.length; i++ )
    {
        boolean result = Arrays.equals( src2D[i], ((MLDouble)mlArrayRetrived ).getArray()[i] );
        assertEquals( "2D array match", true, result );
    }
    
    //test new constructor
    MLArray mlDouble2D = new MLDouble(name, src2D );
    //compare it with original
    assertEquals( "Test if double[][] constructor produces the same matrix as normal one", mlDouble2D, mlDouble );
}