Examples with HeaderWrapper it.geosolutions.imageio.plugins.nitronitf.wrapper.HeaderWrapper used on opensource projects

Example 1 with HeaderWrapper

use of it.geosolutions.imageio.plugins.nitronitf.wrapper.HeaderWrapper in project imageio-ext by geosolutions-it.

the class WriterTest method testNITFWrite.

@Test
@Ignore
public /**
 * Simple writing code which won't be run. You can use it as a sample on how to
 * setup some writing machinery.
 *
 * @throws IOException
 * @throws NITFException
 */
void testNITFWrite() throws IOException, NITFException {
    // This TEST won't run, you can use it as a sample on how to setup some writing code
    if (!NITFUtilities.isNITFAvailable()) {
        System.out.println("NITF native libs aren't available: skipping tests");
        return;
    }
    final String[] inputFilePaths = new String[] { "/tmp/sampleForNitf.tif" };
    final String[] requestedCrs = new String[] { "EPSG:32638" };
    FileImageInputStream fisi = new FileImageInputStream(new File("/tmp/license.txt"));
    int length = (int) fisi.length();
    byte[] data = new byte[length];
    fisi.read(data);
    // final int j = 0;
    // String inputFilePath = inputFilePaths[0];
    // 
    // final GeoTiffReader gtReader = new GeoTiffReader(new File(inputFilePath));
    // final GridCoverage2D gridCoverage = gtReader.read(null);
    // final RenderedImage ri = gridCoverage.getRenderedImage();
    // Image to be written
    RenderedImage ri = null;
    final int numBands = ri.getSampleModel().getNumBands();
    // Geometry geom = null;
    // ShapeFileWrapper shpWrapper = buildShape(geom);
    LinkedHashMap<String, Map<String, String>> tresMap = new LinkedHashMap<String, Map<String, String>>();
    // //
    // 
    // Populating TaggedRecordExtensions field with "FAKE" values,
    // for testing purposes
    // 
    // //
    NITFImageWriterSpi SPI = new NITFImageWriterSpi();
    final WriteCompression[] compressions = new WriteCompression[] { WriteCompression.NPJE_NL, WriteCompression.EPJE_NL, WriteCompression.NPJE_VL, WriteCompression.EPJE_VL };
    for (int w = 0; w < 4; w++) {
        final NITFImageWriter writer = new NITFImageWriter(SPI);
        final WriteCompression compression = compressions[w];
        String fileName = "/tmp/output_" + (numBands == 1 ? "PAN_" : "MULTI_") + compression.toString() + "_jp2.ntf";
        File nitfFile = new File(fileName);
        HeaderWrapper header = setupDefaultHeaderWrapper();
        Calendar cal = Calendar.getInstance();
        String timeStamp = null;
        synchronized (SDF) {
            // not thread safe
            timeStamp = SDF.format(cal.getTime());
        }
        header.setDateTime(timeStamp);
        List<TextWrapper> texts = new LinkedList<TextWrapper>();
        // Adding 3 text segments
        for (int i = 0; i < 3; i++) {
            TextWrapper text = setupDefaultNITFText();
            if (i > 0) {
                text.setTitle("SAMPLE" + i);
                text.setId("ID" + i);
            }
            text.setTextContent(data);
            texts.add(text);
        }
        header.setTitle(nitfFile.getName());
        NITFImageWriteParam param = new NITFImageWriteParam();
        NITFProperties metadata = new NITFProperties();
        param.setWriteCompression(compression);
        writer.setOutput(nitfFile);
        ImageWrapper image = new ImageWrapper();
        image.setImage(ri);
        image.setSource(DEFAULT_IMAGE_SOURCE);
        image.setTitle(numBands == 1 ? "SamplePanchromaticImagery.ntf" : "SampleMultiSpectralImagery.NTF");
        image.setId(numBands == 1 ? "P100000000" : "M100000000");
        List<String> comments = new ArrayList<String>(5);
        comments.add("The imagery and metadata data has been added ");
        comments.add("for testing purposes");
        comments.add("This is a test comment");
        comments.add("made of 5 lines");
        comments.add("of text.");
        image.setComments(comments);
        image.setCompression(compression);
        image.setDateTime(timeStamp);
        image.setImageCoordinateSystem("G");
        image.setIgeolo("453131173651215453133773651210453133713650902453131113650907");
        image.setImageMagnification("1.0");
        final int nBands = ri.getSampleModel().getNumBands();
        image.setImageCategory(nBands > 1 ? Category.MS : Category.VIS);
        Representation r = nBands > 1 ? Representation.RGB : Representation.MONO;
        String rString = r.toString();
        image.setRepresentation(r);
        ImageBand[] imageBands = new ImageBand[nBands];
        if (nBands == 1) {
            imageBands[0] = new ImageBand("", "" + rString.charAt(0));
        } else {
            for (int i = 0; i < nBands; i++) {
                imageBands[i] = new ImageBand("" + (rString.charAt(i)), "" + (rString.charAt(i)));
            }
        }
        image.setBands(imageBands);
        List<ImageWrapper> imagesWrapper = new ArrayList<ImageWrapper>();
        imagesWrapper.add(image);
        metadata.setHeader(header);
        // metadata.setShape(shpWrapper);
        image.setTres(tresMap);
        metadata.setImagesWrapper(imagesWrapper);
        metadata.setTextsWrapper(texts);
        param.setNitfProperties(metadata);
        writer.write(null, new IIOImage(ri, null, null), param);
        writer.dispose();
    // gtReader.dispose();
    }
}

Example 2 with HeaderWrapper

use of it.geosolutions.imageio.plugins.nitronitf.wrapper.HeaderWrapper in project imageio-ext by geosolutions-it.

the class NITFImageWriter method write.

@Override
public void write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param) throws IOException {
    // Headers and segments initialization
    NITFImageWriteParam nitfParam = null;
    HeaderWrapper header = null;
    Map<String, Map<String, String>> extensionsMap = null;
    ShapeFileWrapper shape = null;
    List<TextWrapper> texts = null;
    WriteCompression compression = null;
    List<ImageWrapper> inputImages = null;
    if (param != null && param instanceof NITFImageWriteParam) {
        nitfParam = (NITFImageWriteParam) param;
        NITFProperties nitfMetadata = nitfParam.getNitfProperties();
        if (nitfMetadata != null) {
            header = nitfMetadata.getHeader();
            shape = nitfMetadata.getShape();
            texts = nitfMetadata.getTextsWrapper();
            inputImages = nitfMetadata.getImagesWrapper();
        }
        compression = nitfParam.getWriteCompression();
    }
    ImageWrapper imageW = inputImages.get(0);
    RenderedImage ri = imageW.getImage();
    final boolean isJP2 = (compression != null && compression != WriteCompression.UNCOMPRESSED);
    FileImageInputStreamExt jp2Stream = null;
    File tempFile = null;
    try {
        Record record = new Record(Version.NITF_21);
        if (isJP2) {
            // Proceeding with jp2 compression
            if (JP2_TEMP_FOLDER != null) {
                tempFile = File.createTempFile("jp2compressed", ".jpc", new File(JP2_TEMP_FOLDER));
            }
            String parentPath = outputFile.getParent();
            String name = FilenameUtils.getBaseName(outputFile.getCanonicalPath());
            tempFile = new File(parentPath + File.separatorChar + name + ".j2c");
            prepareJP2Image(ri, tempFile, compression);
            jp2Stream = new FileImageInputStreamExtImpl(tempFile);
        }
        // populating the file header
        initFileHeader(record, header);
        // adding an image segment to the record
        addImageSegment(record, inputImages, jp2Stream, compression);
        if (texts != null && !texts.isEmpty()) {
            // adding a text segment if present
            addTextSegment(record, texts);
        }
        if (!writeNITF(record, inputImages, shape, jp2Stream, texts)) {
            throw new IOException("Unable to successfully write");
        }
    } catch (Throwable t) {
        IOException ioe = new IOException();
        ioe.initCause(t);
        throw ioe;
    } finally {
        // Releasing resources
        if (jp2Stream != null) {
            try {
                jp2Stream.close();
            } catch (Throwable thr) {
            // Eat exception
            }
        }
        if (tempFile != null) {
            try {
                tempFile.delete();
            } catch (Throwable thr) {
            }
        }
    }
    // record.destruct();
    if (LOGGER.isLoggable(Level.FINE)) {
        LOGGER.log(Level.FINE, "Successfully wrote NITF: " + outputFile);
    }
}

Example 3 with HeaderWrapper

use of it.geosolutions.imageio.plugins.nitronitf.wrapper.HeaderWrapper in project imageio-ext by geosolutions-it.

the class WriterTest method setupDefaultHeaderWrapper.

// static void writeShape(final String filePath, Geometry geometry) throws IOException {
// // create feature type
// final SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
// b.setName("raster2vector");
// b.setCRS(DEF_CRS);
// b.add("the_geom", Polygon.class);
// b.add("cat", Integer.class);
// SimpleFeatureType type = b.buildFeatureType();
// final SimpleFeatureCollection outGeodata = FeatureCollections.newCollection();
// 
// // add features
// final SimpleFeatureBuilder builder = new SimpleFeatureBuilder(type);
// final Object[] values = new Object[] { geometry, 0 };
// builder.addAll(values);
// final SimpleFeature feature = builder.buildFeature(type.getTypeName() + "." + 0);
// outGeodata.add(feature);
// 
// // create shapefile
// writeShape(filePath, DEF_CRS, outGeodata);
// }
// 
// static void writeShape(final String filePath, final CoordinateReferenceSystem crs,
// SimpleFeatureCollection data) throws IOException {
// Utilities.ensureNonNull("String", filePath);
// Utilities.ensureNonNull("file Path", data);
// 
// final File file = new File(filePath);
// 
// // Creating the schema
// final DataStoreFactorySpi dataStoreFactory = new ShapefileDataStoreFactory();
// SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
// b.setName("raster2vector");
// if (crs != null) {
// b.setCRS(crs);
// }
// b.add("the_geom", Polygon.class);
// b.add("cat", Integer.class);
// SimpleFeatureType type = b.buildFeatureType();
// final Map<String, Serializable> params = new HashMap<String, Serializable>();
// params.put("url", DataUtilities.fileToURL(file));
// params.put("create spatial index", Boolean.TRUE);
// final ShapefileDataStore newDataStore = (ShapefileDataStore) dataStoreFactory
// .createNewDataStore(params);
// newDataStore.createSchema(type);
// if (crs != null)
// newDataStore.forceSchemaCRS(crs);
// 
// // Write the features to the shapefile
// Transaction transaction = new DefaultTransaction("create");
// 
// String typeName = newDataStore.getTypeNames()[0];
// FeatureSource featureSource = newDataStore.getFeatureSource(typeName);
// 
// if (featureSource instanceof FeatureStore) {
// FeatureStore featureStore = (FeatureStore) featureSource;
// 
// featureStore.setTransaction(transaction);
// try {
// featureStore.addFeatures(data);
// transaction.commit();
// 
// } catch (Exception problem) {
// transaction.rollback();
// 
// } finally {
// transaction.close();
// }
// }
// 
// try {
// if (newDataStore != null)
// newDataStore.dispose();
// } catch (Throwable e) {
// 
// }
// 
// }
// 
// private ShapeFileWrapper buildShape(Geometry footprint) throws NITFException, IOException {
// if (footprint == null) {
// return null;
// }
// final File shpFile = File.createTempFile("csshpa", ".shp");
// final String shpFilePath = shpFile.getAbsolutePath();
// writeShape(shpFilePath, footprint);
// 
// byte[] bshp = new byte[2048];
// byte[] bshx = new byte[2048];
// byte[] bdbf = new byte[2048];
// final String shpFilePrefix = shpFilePath.substring(0, shpFilePath.length() - 3);
// final String dbfFilePath = shpFilePrefix + "dbf";
// final String shxFilePath = shpFilePrefix + "shx";
// final File shxFile = new File(shxFilePath);
// final File dbfFile = new File(dbfFilePath);
// if (!(shxFile.exists() && shxFile.canRead() && dbfFile.exists() && dbfFile.canRead()
// && shpFile.exists() && shpFile.canRead())) {
// throw new NITFException("Unable to write CSSHPA ShapeFile");
// }
// 
// FileInputStream fisSHP = new FileInputStream(shpFilePath);
// FileInputStream fisSHX = new FileInputStream(shxFilePath);
// FileInputStream fisDBF = new FileInputStream(dbfFilePath);
// 
// try {
// final int shp = fisSHP.read(bshp);
// final int shx = fisSHX.read(bshx);
// final int dbf = fisDBF.read(bdbf);
// ShapeFileWrapper wrapper = new ShapeFileWrapper(bshp, bshx, bdbf, shp, shx, dbf);
// return wrapper;
// } finally {
// if (fisSHP != null) {
// IOUtils.closeQuietly(fisSHP);
// }
// if (fisSHX != null) {
// IOUtils.closeQuietly(fisSHX);
// }
// if (fisDBF != null) {
// IOUtils.closeQuietly(fisDBF);
// }
// if (!shpFile.delete()) {
// FileUtils.deleteQuietly(shpFile);
// }
// if (!shxFile.delete()) {
// FileUtils.deleteQuietly(shxFile);
// }
// 
// if (!dbfFile.delete()) {
// FileUtils.deleteQuietly(dbfFile);
// }
// }
// 
// }
public static HeaderWrapper setupDefaultHeaderWrapper() {
    HeaderWrapper headerWrapper = new HeaderWrapper();
    headerWrapper.setOriginatorName("GeoSolutions");
    headerWrapper.setOriginatorPhone("+390584962313");
    headerWrapper.setOriginStationId("GS");
    headerWrapper.setBackgroundColor(new byte[] { 0x7e, 0x7e, 0x7e });
    return headerWrapper;
}