The NITF (National Image Transition Format) format is a file format developed by the U.S. Government for storing imagery, e.g. from satellites.
According to the foreword of the specification:
The National Imagery Transmission Format Standard (NITFS) is the suite of standards for formatting digital imagery and imagery-related products and exchanging them among members of the Intelligence Community (IC) as defined by the Executive Order 12333, and other United States Government departments and agencies."
This implementation is set to version format (file_version) of 02.10 and standard_type of BF01.
It was implemented by River Loop Security.
This page hosts a formal specification of National Imagery Transmission Format using Kaitai Struct. This specification can be automatically translated into a variety of programming languages to get a parsing library.
// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
import io.kaitai.struct.ByteBufferKaitaiStream;
import io.kaitai.struct.KaitaiStruct;
import io.kaitai.struct.KaitaiStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Objects;
import io.kaitai.struct.ConsistencyError;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.nio.charset.Charset;
import java.util.List;
/**
* The NITF (National Image Transition Format) format is a file format developed by the U.S. Government for
* storing imagery, e.g. from satellites.
*
* According to the [foreword of the specification](https://web.archive.org/web/20181105050336/https://www.gwg.nga.mil/ntb/baseline/docs/2500c/2500C.pdf):
* > The National Imagery Transmission Format Standard (NITFS) is the suite of standards for formatting digital
* > imagery and imagery-related products and exchanging them among members of the Intelligence Community (IC) as
* > defined by the Executive Order 12333, and other United States Government departments and agencies."
*
* This implementation is set to version format (`file_version`) of 02.10 and `standard_type` of `BF01`.
* It was implemented by [River Loop Security](https://www.riverloopsecurity.com/).
* @see <a href="https://web.archive.org/web/20181105050336/https://www.gwg.nga.mil/ntb/baseline/docs/2500c/2500C.pdf">Source</a>
*/
public class Nitf extends KaitaiStruct.ReadWrite {
public static Nitf fromFile(String fileName) throws IOException {
return new Nitf(new ByteBufferKaitaiStream(fileName));
}
public Nitf() {
this(null, null, null);
}
public Nitf(KaitaiStream _io) {
this(_io, null, null);
}
public Nitf(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public Nitf(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root == null ? this : _root;
}
public void _read() {
this.header = new Header(this._io, this, _root);
this.header._read();
this.imageSegments = new ArrayList<ImageSegment>();
for (int i = 0; i < Long.parseLong(header().numImageSegments(), 10); i++) {
ImageSegment _t_imageSegments = new ImageSegment(this._io, this, _root, i);
try {
_t_imageSegments._read();
} finally {
this.imageSegments.add(_t_imageSegments);
}
}
this.graphicsSegments = new ArrayList<GraphicsSegment>();
for (int i = 0; i < Long.parseLong(header().numGraphicsSegments(), 10); i++) {
GraphicsSegment _t_graphicsSegments = new GraphicsSegment(this._io, this, _root, i);
try {
_t_graphicsSegments._read();
} finally {
this.graphicsSegments.add(_t_graphicsSegments);
}
}
this.textSegments = new ArrayList<TextSegment>();
for (int i = 0; i < Long.parseLong(header().numTextFiles(), 10); i++) {
TextSegment _t_textSegments = new TextSegment(this._io, this, _root, i);
try {
_t_textSegments._read();
} finally {
this.textSegments.add(_t_textSegments);
}
}
this.dataExtensionSegments = new ArrayList<DataExtensionSegment>();
for (int i = 0; i < Long.parseLong(header().numDataExtension(), 10); i++) {
DataExtensionSegment _t_dataExtensionSegments = new DataExtensionSegment(this._io, this, _root, i);
try {
_t_dataExtensionSegments._read();
} finally {
this.dataExtensionSegments.add(_t_dataExtensionSegments);
}
}
this.reservedExtensionSegments = new ArrayList<ReservedExtensionSegment>();
for (int i = 0; i < Long.parseLong(header().numReservedExtension(), 10); i++) {
ReservedExtensionSegment _t_reservedExtensionSegments = new ReservedExtensionSegment(this._io, this, _root, i);
try {
_t_reservedExtensionSegments._read();
} finally {
this.reservedExtensionSegments.add(_t_reservedExtensionSegments);
}
}
_dirty = false;
}
public void _fetchInstances() {
this.header._fetchInstances();
for (int i = 0; i < this.imageSegments.size(); i++) {
this.imageSegments.get(((Number) (i)).intValue())._fetchInstances();
}
for (int i = 0; i < this.graphicsSegments.size(); i++) {
this.graphicsSegments.get(((Number) (i)).intValue())._fetchInstances();
}
for (int i = 0; i < this.textSegments.size(); i++) {
this.textSegments.get(((Number) (i)).intValue())._fetchInstances();
}
for (int i = 0; i < this.dataExtensionSegments.size(); i++) {
this.dataExtensionSegments.get(((Number) (i)).intValue())._fetchInstances();
}
for (int i = 0; i < this.reservedExtensionSegments.size(); i++) {
this.reservedExtensionSegments.get(((Number) (i)).intValue())._fetchInstances();
}
}
public void _write_Seq() {
_assertNotDirty();
this.header._write_Seq(this._io);
for (int i = 0; i < this.imageSegments.size(); i++) {
this.imageSegments.get(((Number) (i)).intValue())._write_Seq(this._io);
}
for (int i = 0; i < this.graphicsSegments.size(); i++) {
this.graphicsSegments.get(((Number) (i)).intValue())._write_Seq(this._io);
}
for (int i = 0; i < this.textSegments.size(); i++) {
this.textSegments.get(((Number) (i)).intValue())._write_Seq(this._io);
}
for (int i = 0; i < this.dataExtensionSegments.size(); i++) {
this.dataExtensionSegments.get(((Number) (i)).intValue())._write_Seq(this._io);
}
for (int i = 0; i < this.reservedExtensionSegments.size(); i++) {
this.reservedExtensionSegments.get(((Number) (i)).intValue())._write_Seq(this._io);
}
}
public void _check() {
if (!Objects.equals(this.header._root(), _root()))
throw new ConsistencyError("header", _root(), this.header._root());
if (!Objects.equals(this.header._parent(), this))
throw new ConsistencyError("header", this, this.header._parent());
if (this.imageSegments.size() != Long.parseLong(header().numImageSegments(), 10))
throw new ConsistencyError("image_segments", Long.parseLong(header().numImageSegments(), 10), this.imageSegments.size());
for (int i = 0; i < this.imageSegments.size(); i++) {
if (!Objects.equals(this.imageSegments.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("image_segments", _root(), this.imageSegments.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.imageSegments.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("image_segments", this, this.imageSegments.get(((Number) (i)).intValue())._parent());
if (this.imageSegments.get(((Number) (i)).intValue()).idx() != i)
throw new ConsistencyError("image_segments", i, this.imageSegments.get(((Number) (i)).intValue()).idx());
}
if (this.graphicsSegments.size() != Long.parseLong(header().numGraphicsSegments(), 10))
throw new ConsistencyError("graphics_segments", Long.parseLong(header().numGraphicsSegments(), 10), this.graphicsSegments.size());
for (int i = 0; i < this.graphicsSegments.size(); i++) {
if (!Objects.equals(this.graphicsSegments.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("graphics_segments", _root(), this.graphicsSegments.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.graphicsSegments.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("graphics_segments", this, this.graphicsSegments.get(((Number) (i)).intValue())._parent());
if (this.graphicsSegments.get(((Number) (i)).intValue()).idx() != i)
throw new ConsistencyError("graphics_segments", i, this.graphicsSegments.get(((Number) (i)).intValue()).idx());
}
if (this.textSegments.size() != Long.parseLong(header().numTextFiles(), 10))
throw new ConsistencyError("text_segments", Long.parseLong(header().numTextFiles(), 10), this.textSegments.size());
for (int i = 0; i < this.textSegments.size(); i++) {
if (!Objects.equals(this.textSegments.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("text_segments", _root(), this.textSegments.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.textSegments.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("text_segments", this, this.textSegments.get(((Number) (i)).intValue())._parent());
if (this.textSegments.get(((Number) (i)).intValue()).idx() != i)
throw new ConsistencyError("text_segments", i, this.textSegments.get(((Number) (i)).intValue()).idx());
}
if (this.dataExtensionSegments.size() != Long.parseLong(header().numDataExtension(), 10))
throw new ConsistencyError("data_extension_segments", Long.parseLong(header().numDataExtension(), 10), this.dataExtensionSegments.size());
for (int i = 0; i < this.dataExtensionSegments.size(); i++) {
if (!Objects.equals(this.dataExtensionSegments.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("data_extension_segments", _root(), this.dataExtensionSegments.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.dataExtensionSegments.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("data_extension_segments", this, this.dataExtensionSegments.get(((Number) (i)).intValue())._parent());
if (this.dataExtensionSegments.get(((Number) (i)).intValue()).idx() != i)
throw new ConsistencyError("data_extension_segments", i, this.dataExtensionSegments.get(((Number) (i)).intValue()).idx());
}
if (this.reservedExtensionSegments.size() != Long.parseLong(header().numReservedExtension(), 10))
throw new ConsistencyError("reserved_extension_segments", Long.parseLong(header().numReservedExtension(), 10), this.reservedExtensionSegments.size());
for (int i = 0; i < this.reservedExtensionSegments.size(); i++) {
if (!Objects.equals(this.reservedExtensionSegments.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("reserved_extension_segments", _root(), this.reservedExtensionSegments.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.reservedExtensionSegments.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("reserved_extension_segments", this, this.reservedExtensionSegments.get(((Number) (i)).intValue())._parent());
if (this.reservedExtensionSegments.get(((Number) (i)).intValue()).idx() != i)
throw new ConsistencyError("reserved_extension_segments", i, this.reservedExtensionSegments.get(((Number) (i)).intValue()).idx());
}
_dirty = false;
}
public static class BandInfo extends KaitaiStruct.ReadWrite {
public static BandInfo fromFile(String fileName) throws IOException {
return new BandInfo(new ByteBufferKaitaiStream(fileName));
}
public BandInfo() {
this(null, null, null);
}
public BandInfo(KaitaiStream _io) {
this(_io, null, null);
}
public BandInfo(KaitaiStream _io, Nitf.ImageSubHeader _parent) {
this(_io, _parent, null);
}
public BandInfo(KaitaiStream _io, Nitf.ImageSubHeader _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.representation = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.subcategory = new String(this._io.readBytes(6), StandardCharsets.UTF_8);
this.imgFilterCondition = this._io.readBytes(1);
if (!(Arrays.equals(this.imgFilterCondition, new byte[] { 78 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 78 }, this.imgFilterCondition, this._io, "/types/band_info/seq/2");
}
this.imgFilterCode = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.numLuts = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
if (Long.parseLong(numLuts(), 10) != 0) {
this.numLutEntries = new String(this._io.readBytes(5), StandardCharsets.UTF_8);
}
this.luts = new ArrayList<byte[]>();
for (int i = 0; i < Long.parseLong(numLuts(), 10); i++) {
this.luts.add(this._io.readBytes(Long.parseLong(numLutEntries(), 10)));
}
_dirty = false;
}
public void _fetchInstances() {
if (Long.parseLong(numLuts(), 10) != 0) {
}
for (int i = 0; i < this.luts.size(); i++) {
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.representation).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.subcategory).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes(this.imgFilterCondition);
this._io.writeBytes((this.imgFilterCode).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numLuts).getBytes(Charset.forName("UTF-8")));
if (Long.parseLong(numLuts(), 10) != 0) {
this._io.writeBytes((this.numLutEntries).getBytes(Charset.forName("UTF-8")));
}
for (int i = 0; i < this.luts.size(); i++) {
this._io.writeBytes(this.luts.get(((Number) (i)).intValue()));
}
}
public void _check() {
if ((this.representation).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("representation", 2, (this.representation).getBytes(Charset.forName("UTF-8")).length);
if ((this.subcategory).getBytes(Charset.forName("UTF-8")).length != 6)
throw new ConsistencyError("subcategory", 6, (this.subcategory).getBytes(Charset.forName("UTF-8")).length);
if (this.imgFilterCondition.length != 1)
throw new ConsistencyError("img_filter_condition", 1, this.imgFilterCondition.length);
if (!(Arrays.equals(this.imgFilterCondition, new byte[] { 78 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 78 }, this.imgFilterCondition, null, "/types/band_info/seq/2");
}
if ((this.imgFilterCode).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("img_filter_code", 3, (this.imgFilterCode).getBytes(Charset.forName("UTF-8")).length);
if ((this.numLuts).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("num_luts", 1, (this.numLuts).getBytes(Charset.forName("UTF-8")).length);
if (Long.parseLong(numLuts(), 10) != 0) {
if ((this.numLutEntries).getBytes(Charset.forName("UTF-8")).length != 5)
throw new ConsistencyError("num_lut_entries", 5, (this.numLutEntries).getBytes(Charset.forName("UTF-8")).length);
}
if (this.luts.size() != Long.parseLong(numLuts(), 10))
throw new ConsistencyError("luts", Long.parseLong(numLuts(), 10), this.luts.size());
for (int i = 0; i < this.luts.size(); i++) {
if (this.luts.get(((Number) (i)).intValue()).length != Long.parseLong(numLutEntries(), 10))
throw new ConsistencyError("luts", Long.parseLong(numLutEntries(), 10), this.luts.get(((Number) (i)).intValue()).length);
}
_dirty = false;
}
private String representation;
private String subcategory;
private byte[] imgFilterCondition;
private String imgFilterCode;
private String numLuts;
private String numLutEntries;
private List<byte[]> luts;
private Nitf _root;
private Nitf.ImageSubHeader _parent;
/**
* Indicates processing required to display the nth band of image w.r.t. the general image type recorded by IREP field
*/
public String representation() { return representation; }
public void setRepresentation(String _v) { _dirty = true; representation = _v; }
public String subcategory() { return subcategory; }
public void setSubcategory(String _v) { _dirty = true; subcategory = _v; }
public byte[] imgFilterCondition() { return imgFilterCondition; }
public void setImgFilterCondition(byte[] _v) { _dirty = true; imgFilterCondition = _v; }
/**
* Reserved
*/
public String imgFilterCode() { return imgFilterCode; }
public void setImgFilterCode(String _v) { _dirty = true; imgFilterCode = _v; }
public String numLuts() { return numLuts; }
public void setNumLuts(String _v) { _dirty = true; numLuts = _v; }
/**
* Number of entries in each of the LUTs for the nth image band
*/
public String numLutEntries() { return numLutEntries; }
public void setNumLutEntries(String _v) { _dirty = true; numLutEntries = _v; }
public List<byte[]> luts() { return luts; }
public void setLuts(List<byte[]> _v) { _dirty = true; luts = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.ImageSubHeader _parent() { return _parent; }
public void set_parent(Nitf.ImageSubHeader _v) { _dirty = true; _parent = _v; }
}
public static class Clasnfo extends KaitaiStruct.ReadWrite {
public static Clasnfo fromFile(String fileName) throws IOException {
return new Clasnfo(new ByteBufferKaitaiStream(fileName));
}
public Clasnfo() {
this(null, null, null);
}
public Clasnfo(KaitaiStream _io) {
this(_io, null, null);
}
public Clasnfo(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public Clasnfo(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.securityClass = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.securitySystem = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.codewords = new String(this._io.readBytes(11), StandardCharsets.UTF_8);
this.controlAndHandling = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.releaseability = new String(this._io.readBytes(20), StandardCharsets.UTF_8);
this.declassType = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.declassDate = new String(this._io.readBytes(8), StandardCharsets.UTF_8);
this.declassExemption = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.downgrade = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.downgradeDate = new String(this._io.readBytes(8), StandardCharsets.UTF_8);
this.classText = new String(this._io.readBytes(43), StandardCharsets.UTF_8);
this.classAuthorityType = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.classAuthority = new String(this._io.readBytes(40), StandardCharsets.UTF_8);
this.classReason = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.sourceDate = new String(this._io.readBytes(8), StandardCharsets.UTF_8);
this.controlNumber = new String(this._io.readBytes(15), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.securityClass).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.securitySystem).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.codewords).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.controlAndHandling).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.releaseability).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.declassType).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.declassDate).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.declassExemption).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.downgrade).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.downgradeDate).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.classText).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.classAuthorityType).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.classAuthority).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.classReason).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.sourceDate).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.controlNumber).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this.securityClass).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("security_class", 1, (this.securityClass).getBytes(Charset.forName("UTF-8")).length);
if ((this.securitySystem).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("security_system", 2, (this.securitySystem).getBytes(Charset.forName("UTF-8")).length);
if ((this.codewords).getBytes(Charset.forName("UTF-8")).length != 11)
throw new ConsistencyError("codewords", 11, (this.codewords).getBytes(Charset.forName("UTF-8")).length);
if ((this.controlAndHandling).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("control_and_handling", 2, (this.controlAndHandling).getBytes(Charset.forName("UTF-8")).length);
if ((this.releaseability).getBytes(Charset.forName("UTF-8")).length != 20)
throw new ConsistencyError("releaseability", 20, (this.releaseability).getBytes(Charset.forName("UTF-8")).length);
if ((this.declassType).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("declass_type", 2, (this.declassType).getBytes(Charset.forName("UTF-8")).length);
if ((this.declassDate).getBytes(Charset.forName("UTF-8")).length != 8)
throw new ConsistencyError("declass_date", 8, (this.declassDate).getBytes(Charset.forName("UTF-8")).length);
if ((this.declassExemption).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("declass_exemption", 4, (this.declassExemption).getBytes(Charset.forName("UTF-8")).length);
if ((this.downgrade).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("downgrade", 1, (this.downgrade).getBytes(Charset.forName("UTF-8")).length);
if ((this.downgradeDate).getBytes(Charset.forName("UTF-8")).length != 8)
throw new ConsistencyError("downgrade_date", 8, (this.downgradeDate).getBytes(Charset.forName("UTF-8")).length);
if ((this.classText).getBytes(Charset.forName("UTF-8")).length != 43)
throw new ConsistencyError("class_text", 43, (this.classText).getBytes(Charset.forName("UTF-8")).length);
if ((this.classAuthorityType).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("class_authority_type", 1, (this.classAuthorityType).getBytes(Charset.forName("UTF-8")).length);
if ((this.classAuthority).getBytes(Charset.forName("UTF-8")).length != 40)
throw new ConsistencyError("class_authority", 40, (this.classAuthority).getBytes(Charset.forName("UTF-8")).length);
if ((this.classReason).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("class_reason", 1, (this.classReason).getBytes(Charset.forName("UTF-8")).length);
if ((this.sourceDate).getBytes(Charset.forName("UTF-8")).length != 8)
throw new ConsistencyError("source_date", 8, (this.sourceDate).getBytes(Charset.forName("UTF-8")).length);
if ((this.controlNumber).getBytes(Charset.forName("UTF-8")).length != 15)
throw new ConsistencyError("control_number", 15, (this.controlNumber).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String securityClass;
private String securitySystem;
private String codewords;
private String controlAndHandling;
private String releaseability;
private String declassType;
private String declassDate;
private String declassExemption;
private String downgrade;
private String downgradeDate;
private String classText;
private String classAuthorityType;
private String classAuthority;
private String classReason;
private String sourceDate;
private String controlNumber;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
public String securityClass() { return securityClass; }
public void setSecurityClass(String _v) { _dirty = true; securityClass = _v; }
public String securitySystem() { return securitySystem; }
public void setSecuritySystem(String _v) { _dirty = true; securitySystem = _v; }
public String codewords() { return codewords; }
public void setCodewords(String _v) { _dirty = true; codewords = _v; }
public String controlAndHandling() { return controlAndHandling; }
public void setControlAndHandling(String _v) { _dirty = true; controlAndHandling = _v; }
public String releaseability() { return releaseability; }
public void setReleaseability(String _v) { _dirty = true; releaseability = _v; }
public String declassType() { return declassType; }
public void setDeclassType(String _v) { _dirty = true; declassType = _v; }
public String declassDate() { return declassDate; }
public void setDeclassDate(String _v) { _dirty = true; declassDate = _v; }
public String declassExemption() { return declassExemption; }
public void setDeclassExemption(String _v) { _dirty = true; declassExemption = _v; }
public String downgrade() { return downgrade; }
public void setDowngrade(String _v) { _dirty = true; downgrade = _v; }
public String downgradeDate() { return downgradeDate; }
public void setDowngradeDate(String _v) { _dirty = true; downgradeDate = _v; }
public String classText() { return classText; }
public void setClassText(String _v) { _dirty = true; classText = _v; }
public String classAuthorityType() { return classAuthorityType; }
public void setClassAuthorityType(String _v) { _dirty = true; classAuthorityType = _v; }
public String classAuthority() { return classAuthority; }
public void setClassAuthority(String _v) { _dirty = true; classAuthority = _v; }
public String classReason() { return classReason; }
public void setClassReason(String _v) { _dirty = true; classReason = _v; }
public String sourceDate() { return sourceDate; }
public void setSourceDate(String _v) { _dirty = true; sourceDate = _v; }
public String controlNumber() { return controlNumber; }
public void setControlNumber(String _v) { _dirty = true; controlNumber = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class DataExtensionSegment extends KaitaiStruct.ReadWrite {
public DataExtensionSegment(int idx) {
this(null, null, null, idx);
}
public DataExtensionSegment(KaitaiStream _io, int idx) {
this(_io, null, null, idx);
}
public DataExtensionSegment(KaitaiStream _io, Nitf _parent, int idx) {
this(_io, _parent, null, idx);
}
public DataExtensionSegment(KaitaiStream _io, Nitf _parent, Nitf _root, int idx) {
super(_io);
this._parent = _parent;
this._root = _root;
this.idx = idx;
}
public void _read() {
this._raw_dataSubHeader = this._io.readBytes(Long.parseLong(_parent().header().ldnfo().get(((Number) (idx())).intValue()).lengthDataExtensionSubheader(), 10));
KaitaiStream _io__raw_dataSubHeader = new ByteBufferKaitaiStream(this._raw_dataSubHeader);
this.dataSubHeader = new DataSubHeader(_io__raw_dataSubHeader, this, _root);
this.dataSubHeader._read();
this.dataDataField = this._io.readBytes(Long.parseLong(_parent().header().ldnfo().get(((Number) (idx())).intValue()).lengthDataExtensionSegment(), 10));
_dirty = false;
}
public void _fetchInstances() {
this.dataSubHeader._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
final KaitaiStream _io__raw_dataSubHeader = new ByteBufferKaitaiStream(Long.parseLong(_parent().header().ldnfo().get(((Number) (idx())).intValue()).lengthDataExtensionSubheader(), 10));
this._io.addChildStream(_io__raw_dataSubHeader);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (Long.parseLong(_parent().header().ldnfo().get(((Number) (idx())).intValue()).lengthDataExtensionSubheader(), 10)));
final DataExtensionSegment _this = this;
_io__raw_dataSubHeader.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_dataSubHeader = _io__raw_dataSubHeader.toByteArray();
if (_this._raw_dataSubHeader.length != Long.parseLong(_parent().header().ldnfo().get(((Number) (idx())).intValue()).lengthDataExtensionSubheader(), 10))
throw new ConsistencyError("raw(data_sub_header)", Long.parseLong(_parent().header().ldnfo().get(((Number) (idx())).intValue()).lengthDataExtensionSubheader(), 10), _this._raw_dataSubHeader.length);
parent.writeBytes(_this._raw_dataSubHeader);
}
});
}
this.dataSubHeader._write_Seq(_io__raw_dataSubHeader);
this._io.writeBytes(this.dataDataField);
}
public void _check() {
if (!Objects.equals(this.dataSubHeader._root(), _root()))
throw new ConsistencyError("data_sub_header", _root(), this.dataSubHeader._root());
if (!Objects.equals(this.dataSubHeader._parent(), this))
throw new ConsistencyError("data_sub_header", this, this.dataSubHeader._parent());
if (this.dataDataField.length != Long.parseLong(_parent().header().ldnfo().get(((Number) (idx())).intValue()).lengthDataExtensionSegment(), 10))
throw new ConsistencyError("data_data_field", Long.parseLong(_parent().header().ldnfo().get(((Number) (idx())).intValue()).lengthDataExtensionSegment(), 10), this.dataDataField.length);
_dirty = false;
}
private DataSubHeader dataSubHeader;
private byte[] dataDataField;
private int idx;
private Nitf _root;
private Nitf _parent;
private byte[] _raw_dataSubHeader;
public DataSubHeader dataSubHeader() { return dataSubHeader; }
public void setDataSubHeader(DataSubHeader _v) { _dirty = true; dataSubHeader = _v; }
public byte[] dataDataField() { return dataDataField; }
public void setDataDataField(byte[] _v) { _dirty = true; dataDataField = _v; }
public int idx() { return idx; }
public void setIdx(int _v) { _dirty = true; idx = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf _parent() { return _parent; }
public void set_parent(Nitf _v) { _dirty = true; _parent = _v; }
public byte[] _raw_dataSubHeader() { return _raw_dataSubHeader; }
public void set_raw_DataSubHeader(byte[] _v) { _dirty = true; _raw_dataSubHeader = _v; }
}
public static class DataSubHeader extends KaitaiStruct.ReadWrite {
public static DataSubHeader fromFile(String fileName) throws IOException {
return new DataSubHeader(new ByteBufferKaitaiStream(fileName));
}
public DataSubHeader() {
this(null, null, null);
}
public DataSubHeader(KaitaiStream _io) {
this(_io, null, null);
}
public DataSubHeader(KaitaiStream _io, Nitf.DataExtensionSegment _parent) {
this(_io, _parent, null);
}
public DataSubHeader(KaitaiStream _io, Nitf.DataExtensionSegment _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.desBase = new DataSubHeaderBase(this._io, this, _root);
this.desBase._read();
if (treOfl()) {
this.overflowedHeaderType = new String(this._io.readBytes(6), StandardCharsets.UTF_8);
}
if (treOfl()) {
this.dataItemOverflowed = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
}
this.desDefinedSubheaderFieldsLen = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.desshf = new String(this._io.readBytes(Long.parseLong(desDefinedSubheaderFieldsLen(), 10)), StandardCharsets.UTF_8);
this.desDefinedDataField = new String(this._io.readBytesFull(), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
this.desBase._fetchInstances();
if (treOfl()) {
}
if (treOfl()) {
}
}
public void _write_Seq() {
_assertNotDirty();
this.desBase._write_Seq(this._io);
if (treOfl()) {
this._io.writeBytes((this.overflowedHeaderType).getBytes(Charset.forName("UTF-8")));
}
if (treOfl()) {
this._io.writeBytes((this.dataItemOverflowed).getBytes(Charset.forName("UTF-8")));
}
this._io.writeBytes((this.desDefinedSubheaderFieldsLen).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.desshf).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.desDefinedDataField).getBytes(Charset.forName("UTF-8")));
if (!(this._io.isEof()))
throw new ConsistencyError("des_defined_data_field", 0, this._io.size() - this._io.pos());
}
public void _check() {
if (!Objects.equals(this.desBase._root(), _root()))
throw new ConsistencyError("des_base", _root(), this.desBase._root());
if (!Objects.equals(this.desBase._parent(), this))
throw new ConsistencyError("des_base", this, this.desBase._parent());
if (treOfl()) {
if ((this.overflowedHeaderType).getBytes(Charset.forName("UTF-8")).length != 6)
throw new ConsistencyError("overflowed_header_type", 6, (this.overflowedHeaderType).getBytes(Charset.forName("UTF-8")).length);
}
if (treOfl()) {
if ((this.dataItemOverflowed).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("data_item_overflowed", 3, (this.dataItemOverflowed).getBytes(Charset.forName("UTF-8")).length);
}
if ((this.desDefinedSubheaderFieldsLen).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("des_defined_subheader_fields_len", 4, (this.desDefinedSubheaderFieldsLen).getBytes(Charset.forName("UTF-8")).length);
if ((this.desshf).getBytes(Charset.forName("UTF-8")).length != Long.parseLong(desDefinedSubheaderFieldsLen(), 10))
throw new ConsistencyError("desshf", Long.parseLong(desDefinedSubheaderFieldsLen(), 10), (this.desshf).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private Boolean treOfl;
public Boolean treOfl() {
if (this.treOfl != null)
return this.treOfl;
this.treOfl = desBase().desid().equals("TRE_OVERFLOW");
return this.treOfl;
}
public void _invalidateTreOfl() { this.treOfl = null; }
private DataSubHeaderBase desBase;
private String overflowedHeaderType;
private String dataItemOverflowed;
private String desDefinedSubheaderFieldsLen;
private String desshf;
private String desDefinedDataField;
private Nitf _root;
private Nitf.DataExtensionSegment _parent;
public DataSubHeaderBase desBase() { return desBase; }
public void setDesBase(DataSubHeaderBase _v) { _dirty = true; desBase = _v; }
public String overflowedHeaderType() { return overflowedHeaderType; }
public void setOverflowedHeaderType(String _v) { _dirty = true; overflowedHeaderType = _v; }
public String dataItemOverflowed() { return dataItemOverflowed; }
public void setDataItemOverflowed(String _v) { _dirty = true; dataItemOverflowed = _v; }
public String desDefinedSubheaderFieldsLen() { return desDefinedSubheaderFieldsLen; }
public void setDesDefinedSubheaderFieldsLen(String _v) { _dirty = true; desDefinedSubheaderFieldsLen = _v; }
public String desshf() { return desshf; }
public void setDesshf(String _v) { _dirty = true; desshf = _v; }
public String desDefinedDataField() { return desDefinedDataField; }
public void setDesDefinedDataField(String _v) { _dirty = true; desDefinedDataField = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.DataExtensionSegment _parent() { return _parent; }
public void set_parent(Nitf.DataExtensionSegment _v) { _dirty = true; _parent = _v; }
}
public static class DataSubHeaderBase extends KaitaiStruct.ReadWrite {
public static DataSubHeaderBase fromFile(String fileName) throws IOException {
return new DataSubHeaderBase(new ByteBufferKaitaiStream(fileName));
}
public DataSubHeaderBase() {
this(null, null, null);
}
public DataSubHeaderBase(KaitaiStream _io) {
this(_io, null, null);
}
public DataSubHeaderBase(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public DataSubHeaderBase(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.filePartTypeDe = this._io.readBytes(2);
if (!(Arrays.equals(this.filePartTypeDe, new byte[] { 68, 69 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 68, 69 }, this.filePartTypeDe, this._io, "/types/data_sub_header_base/seq/0");
}
this.desid = new String(this._io.readBytes(25), StandardCharsets.UTF_8);
this.dataDefinitionVersion = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.declasnfo = new Clasnfo(this._io, this, _root);
this.declasnfo._read();
_dirty = false;
}
public void _fetchInstances() {
this.declasnfo._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes(this.filePartTypeDe);
this._io.writeBytes((this.desid).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.dataDefinitionVersion).getBytes(Charset.forName("UTF-8")));
this.declasnfo._write_Seq(this._io);
}
public void _check() {
if (this.filePartTypeDe.length != 2)
throw new ConsistencyError("file_part_type_de", 2, this.filePartTypeDe.length);
if (!(Arrays.equals(this.filePartTypeDe, new byte[] { 68, 69 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 68, 69 }, this.filePartTypeDe, null, "/types/data_sub_header_base/seq/0");
}
if ((this.desid).getBytes(Charset.forName("UTF-8")).length != 25)
throw new ConsistencyError("desid", 25, (this.desid).getBytes(Charset.forName("UTF-8")).length);
if ((this.dataDefinitionVersion).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("data_definition_version", 2, (this.dataDefinitionVersion).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.declasnfo._root(), _root()))
throw new ConsistencyError("declasnfo", _root(), this.declasnfo._root());
if (!Objects.equals(this.declasnfo._parent(), this))
throw new ConsistencyError("declasnfo", this, this.declasnfo._parent());
_dirty = false;
}
private byte[] filePartTypeDe;
private String desid;
private String dataDefinitionVersion;
private Clasnfo declasnfo;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
/**
* File Part Type desigantor for Data Extension
*/
public byte[] filePartTypeDe() { return filePartTypeDe; }
public void setFilePartTypeDe(byte[] _v) { _dirty = true; filePartTypeDe = _v; }
public String desid() { return desid; }
public void setDesid(String _v) { _dirty = true; desid = _v; }
public String dataDefinitionVersion() { return dataDefinitionVersion; }
public void setDataDefinitionVersion(String _v) { _dirty = true; dataDefinitionVersion = _v; }
public Clasnfo declasnfo() { return declasnfo; }
public void setDeclasnfo(Clasnfo _v) { _dirty = true; declasnfo = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
/**
* Streaming file Header Data Extension Segment Subheader
*/
public static class DataSubHeaderStreaming extends KaitaiStruct.ReadWrite {
public static DataSubHeaderStreaming fromFile(String fileName) throws IOException {
return new DataSubHeaderStreaming(new ByteBufferKaitaiStream(fileName));
}
public DataSubHeaderStreaming() {
this(null, null, null);
}
public DataSubHeaderStreaming(KaitaiStream _io) {
this(_io, null, null);
}
public DataSubHeaderStreaming(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public DataSubHeaderStreaming(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.desBase = new DataSubHeaderBase(this._io, this, _root);
this.desBase._read();
this.desDefinedSubheaderFieldsLen = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.sfhL1 = new String(this._io.readBytes(7), StandardCharsets.UTF_8);
this.sfhDelim1 = this._io.readU4be();
this.sfhDr = new ArrayList<Integer>();
for (int i = 0; i < Long.parseLong(sfhL1(), 10); i++) {
this.sfhDr.add(this._io.readU1());
}
this.sfhDelim2 = this._io.readU4be();
this.sfhL2 = new String(this._io.readBytes(7), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
this.desBase._fetchInstances();
for (int i = 0; i < this.sfhDr.size(); i++) {
}
}
public void _write_Seq() {
_assertNotDirty();
this.desBase._write_Seq(this._io);
this._io.writeBytes((this.desDefinedSubheaderFieldsLen).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.sfhL1).getBytes(Charset.forName("UTF-8")));
this._io.writeU4be(this.sfhDelim1);
for (int i = 0; i < this.sfhDr.size(); i++) {
this._io.writeU1(this.sfhDr.get(((Number) (i)).intValue()));
}
this._io.writeU4be(this.sfhDelim2);
this._io.writeBytes((this.sfhL2).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if (!Objects.equals(this.desBase._root(), _root()))
throw new ConsistencyError("des_base", _root(), this.desBase._root());
if (!Objects.equals(this.desBase._parent(), this))
throw new ConsistencyError("des_base", this, this.desBase._parent());
if ((this.desDefinedSubheaderFieldsLen).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("des_defined_subheader_fields_len", 4, (this.desDefinedSubheaderFieldsLen).getBytes(Charset.forName("UTF-8")).length);
if ((this.sfhL1).getBytes(Charset.forName("UTF-8")).length != 7)
throw new ConsistencyError("sfh_l1", 7, (this.sfhL1).getBytes(Charset.forName("UTF-8")).length);
if (this.sfhDr.size() != Long.parseLong(sfhL1(), 10))
throw new ConsistencyError("sfh_dr", Long.parseLong(sfhL1(), 10), this.sfhDr.size());
for (int i = 0; i < this.sfhDr.size(); i++) {
}
if ((this.sfhL2).getBytes(Charset.forName("UTF-8")).length != 7)
throw new ConsistencyError("sfh_l2", 7, (this.sfhL2).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private DataSubHeaderBase desBase;
private String desDefinedSubheaderFieldsLen;
private String sfhL1;
private long sfhDelim1;
private List<Integer> sfhDr;
private long sfhDelim2;
private String sfhL2;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
public DataSubHeaderBase desBase() { return desBase; }
public void setDesBase(DataSubHeaderBase _v) { _dirty = true; desBase = _v; }
public String desDefinedSubheaderFieldsLen() { return desDefinedSubheaderFieldsLen; }
public void setDesDefinedSubheaderFieldsLen(String _v) { _dirty = true; desDefinedSubheaderFieldsLen = _v; }
/**
* SFH Length 1: number of bytes in sfh_dr field
*/
public String sfhL1() { return sfhL1; }
public void setSfhL1(String _v) { _dirty = true; sfhL1 = _v; }
/**
* Shall contain the value 0x0A6E1D97.
*/
public long sfhDelim1() { return sfhDelim1; }
public void setSfhDelim1(long _v) { _dirty = true; sfhDelim1 = _v; }
public List<Integer> sfhDr() { return sfhDr; }
public void setSfhDr(List<Integer> _v) { _dirty = true; sfhDr = _v; }
/**
* Shall contain the value 0x0ECA14BF.
*/
public long sfhDelim2() { return sfhDelim2; }
public void setSfhDelim2(long _v) { _dirty = true; sfhDelim2 = _v; }
/**
* A repeat of sfh_l1.
*/
public String sfhL2() { return sfhL2; }
public void setSfhL2(String _v) { _dirty = true; sfhL2 = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class DataSubHeaderTre extends KaitaiStruct.ReadWrite {
public static DataSubHeaderTre fromFile(String fileName) throws IOException {
return new DataSubHeaderTre(new ByteBufferKaitaiStream(fileName));
}
public DataSubHeaderTre() {
this(null, null, null);
}
public DataSubHeaderTre(KaitaiStream _io) {
this(_io, null, null);
}
public DataSubHeaderTre(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public DataSubHeaderTre(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.desBase = new DataSubHeaderBase(this._io, this, _root);
this.desBase._read();
if (desBase().desid().equals("TRE_OVERFLOW")) {
this.overflowedHeaderType = new String(this._io.readBytes(6), StandardCharsets.UTF_8);
}
if (desBase().desid().equals("TRE_OVERFLOW")) {
this.dataItemOverflowed = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
}
this.desDefinedSubheaderFieldsLen = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.desDefinedDataField = new String(this._io.readBytes(Long.parseLong(desDefinedSubheaderFieldsLen(), 10)), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
this.desBase._fetchInstances();
if (desBase().desid().equals("TRE_OVERFLOW")) {
}
if (desBase().desid().equals("TRE_OVERFLOW")) {
}
}
public void _write_Seq() {
_assertNotDirty();
this.desBase._write_Seq(this._io);
if (desBase().desid().equals("TRE_OVERFLOW")) {
this._io.writeBytes((this.overflowedHeaderType).getBytes(Charset.forName("UTF-8")));
}
if (desBase().desid().equals("TRE_OVERFLOW")) {
this._io.writeBytes((this.dataItemOverflowed).getBytes(Charset.forName("UTF-8")));
}
this._io.writeBytes((this.desDefinedSubheaderFieldsLen).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.desDefinedDataField).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if (!Objects.equals(this.desBase._root(), _root()))
throw new ConsistencyError("des_base", _root(), this.desBase._root());
if (!Objects.equals(this.desBase._parent(), this))
throw new ConsistencyError("des_base", this, this.desBase._parent());
if (desBase().desid().equals("TRE_OVERFLOW")) {
if ((this.overflowedHeaderType).getBytes(Charset.forName("UTF-8")).length != 6)
throw new ConsistencyError("overflowed_header_type", 6, (this.overflowedHeaderType).getBytes(Charset.forName("UTF-8")).length);
}
if (desBase().desid().equals("TRE_OVERFLOW")) {
if ((this.dataItemOverflowed).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("data_item_overflowed", 3, (this.dataItemOverflowed).getBytes(Charset.forName("UTF-8")).length);
}
if ((this.desDefinedSubheaderFieldsLen).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("des_defined_subheader_fields_len", 4, (this.desDefinedSubheaderFieldsLen).getBytes(Charset.forName("UTF-8")).length);
if ((this.desDefinedDataField).getBytes(Charset.forName("UTF-8")).length != Long.parseLong(desDefinedSubheaderFieldsLen(), 10))
throw new ConsistencyError("des_defined_data_field", Long.parseLong(desDefinedSubheaderFieldsLen(), 10), (this.desDefinedDataField).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private DataSubHeaderBase desBase;
private String overflowedHeaderType;
private String dataItemOverflowed;
private String desDefinedSubheaderFieldsLen;
private String desDefinedDataField;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
public DataSubHeaderBase desBase() { return desBase; }
public void setDesBase(DataSubHeaderBase _v) { _dirty = true; desBase = _v; }
public String overflowedHeaderType() { return overflowedHeaderType; }
public void setOverflowedHeaderType(String _v) { _dirty = true; overflowedHeaderType = _v; }
public String dataItemOverflowed() { return dataItemOverflowed; }
public void setDataItemOverflowed(String _v) { _dirty = true; dataItemOverflowed = _v; }
public String desDefinedSubheaderFieldsLen() { return desDefinedSubheaderFieldsLen; }
public void setDesDefinedSubheaderFieldsLen(String _v) { _dirty = true; desDefinedSubheaderFieldsLen = _v; }
public String desDefinedDataField() { return desDefinedDataField; }
public void setDesDefinedDataField(String _v) { _dirty = true; desDefinedDataField = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class DateTime extends KaitaiStruct.ReadWrite {
public static DateTime fromFile(String fileName) throws IOException {
return new DateTime(new ByteBufferKaitaiStream(fileName));
}
public DateTime() {
this(null, null, null);
}
public DateTime(KaitaiStream _io) {
this(_io, null, null);
}
public DateTime(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public DateTime(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this._unnamed0 = new String(this._io.readBytes(14), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this._unnamed0).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this._unnamed0).getBytes(Charset.forName("UTF-8")).length != 14)
throw new ConsistencyError("_unnamed0", 14, (this._unnamed0).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String _unnamed0;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
/**
* UTC time of image acquisition in the format CCYYMMDDhhmmss: CC century, YY last two digits of the year, MM month, DD day, hh hour, mm minute, ss second
*/
public String _unnamed0() { return _unnamed0; }
public void set_unnamed0(String _v) { _dirty = true; _unnamed0 = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class Encrypt extends KaitaiStruct.ReadWrite {
public static Encrypt fromFile(String fileName) throws IOException {
return new Encrypt(new ByteBufferKaitaiStream(fileName));
}
public Encrypt() {
this(null, null, null);
}
public Encrypt(KaitaiStream _io) {
this(_io, null, null);
}
public Encrypt(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public Encrypt(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this._unnamed0 = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this._unnamed0).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this._unnamed0).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("_unnamed0", 1, (this._unnamed0).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String _unnamed0;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
public String _unnamed0() { return _unnamed0; }
public void set_unnamed0(String _v) { _dirty = true; _unnamed0 = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class GraphicSubHeader extends KaitaiStruct.ReadWrite {
public static GraphicSubHeader fromFile(String fileName) throws IOException {
return new GraphicSubHeader(new ByteBufferKaitaiStream(fileName));
}
public GraphicSubHeader() {
this(null, null, null);
}
public GraphicSubHeader(KaitaiStream _io) {
this(_io, null, null);
}
public GraphicSubHeader(KaitaiStream _io, Nitf.GraphicsSegment _parent) {
this(_io, _parent, null);
}
public GraphicSubHeader(KaitaiStream _io, Nitf.GraphicsSegment _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.filePartTypeSy = this._io.readBytes(2);
if (!(Arrays.equals(this.filePartTypeSy, new byte[] { 83, 89 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 83, 89 }, this.filePartTypeSy, this._io, "/types/graphic_sub_header/seq/0");
}
this.graphicId = new String(this._io.readBytes(10), StandardCharsets.UTF_8);
this.graphicName = new String(this._io.readBytes(20), StandardCharsets.UTF_8);
this.graphicClassification = new Clasnfo(this._io, this, _root);
this.graphicClassification._read();
this.encryption = new Encrypt(this._io, this, _root);
this.encryption._read();
this.graphicType = this._io.readBytes(1);
if (!(Arrays.equals(this.graphicType, new byte[] { 67 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 67 }, this.graphicType, this._io, "/types/graphic_sub_header/seq/5");
}
this.reserved1 = new String(this._io.readBytes(13), StandardCharsets.UTF_8);
this.graphicDisplayLevel = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.graphicAttachmentLevel = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.graphicLocation = new String(this._io.readBytes(10), StandardCharsets.UTF_8);
this.firstGraphicBoundLoc = new String(this._io.readBytes(10), StandardCharsets.UTF_8);
this.graphicColor = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.secondGraphicBoundLoc = new String(this._io.readBytes(10), StandardCharsets.UTF_8);
this.reserved2 = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.graphicsExtendedSubHeader = new TreHeader(this._io, this, _root);
this.graphicsExtendedSubHeader._read();
_dirty = false;
}
public void _fetchInstances() {
this.graphicClassification._fetchInstances();
this.encryption._fetchInstances();
this.graphicsExtendedSubHeader._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes(this.filePartTypeSy);
this._io.writeBytes((this.graphicId).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.graphicName).getBytes(Charset.forName("UTF-8")));
this.graphicClassification._write_Seq(this._io);
this.encryption._write_Seq(this._io);
this._io.writeBytes(this.graphicType);
this._io.writeBytes((this.reserved1).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.graphicDisplayLevel).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.graphicAttachmentLevel).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.graphicLocation).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.firstGraphicBoundLoc).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.graphicColor).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.secondGraphicBoundLoc).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.reserved2).getBytes(Charset.forName("UTF-8")));
this.graphicsExtendedSubHeader._write_Seq(this._io);
}
public void _check() {
if (this.filePartTypeSy.length != 2)
throw new ConsistencyError("file_part_type_sy", 2, this.filePartTypeSy.length);
if (!(Arrays.equals(this.filePartTypeSy, new byte[] { 83, 89 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 83, 89 }, this.filePartTypeSy, null, "/types/graphic_sub_header/seq/0");
}
if ((this.graphicId).getBytes(Charset.forName("UTF-8")).length != 10)
throw new ConsistencyError("graphic_id", 10, (this.graphicId).getBytes(Charset.forName("UTF-8")).length);
if ((this.graphicName).getBytes(Charset.forName("UTF-8")).length != 20)
throw new ConsistencyError("graphic_name", 20, (this.graphicName).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.graphicClassification._root(), _root()))
throw new ConsistencyError("graphic_classification", _root(), this.graphicClassification._root());
if (!Objects.equals(this.graphicClassification._parent(), this))
throw new ConsistencyError("graphic_classification", this, this.graphicClassification._parent());
if (!Objects.equals(this.encryption._root(), _root()))
throw new ConsistencyError("encryption", _root(), this.encryption._root());
if (!Objects.equals(this.encryption._parent(), this))
throw new ConsistencyError("encryption", this, this.encryption._parent());
if (this.graphicType.length != 1)
throw new ConsistencyError("graphic_type", 1, this.graphicType.length);
if (!(Arrays.equals(this.graphicType, new byte[] { 67 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 67 }, this.graphicType, null, "/types/graphic_sub_header/seq/5");
}
if ((this.reserved1).getBytes(Charset.forName("UTF-8")).length != 13)
throw new ConsistencyError("reserved1", 13, (this.reserved1).getBytes(Charset.forName("UTF-8")).length);
if ((this.graphicDisplayLevel).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("graphic_display_level", 3, (this.graphicDisplayLevel).getBytes(Charset.forName("UTF-8")).length);
if ((this.graphicAttachmentLevel).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("graphic_attachment_level", 3, (this.graphicAttachmentLevel).getBytes(Charset.forName("UTF-8")).length);
if ((this.graphicLocation).getBytes(Charset.forName("UTF-8")).length != 10)
throw new ConsistencyError("graphic_location", 10, (this.graphicLocation).getBytes(Charset.forName("UTF-8")).length);
if ((this.firstGraphicBoundLoc).getBytes(Charset.forName("UTF-8")).length != 10)
throw new ConsistencyError("first_graphic_bound_loc", 10, (this.firstGraphicBoundLoc).getBytes(Charset.forName("UTF-8")).length);
if ((this.graphicColor).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("graphic_color", 1, (this.graphicColor).getBytes(Charset.forName("UTF-8")).length);
if ((this.secondGraphicBoundLoc).getBytes(Charset.forName("UTF-8")).length != 10)
throw new ConsistencyError("second_graphic_bound_loc", 10, (this.secondGraphicBoundLoc).getBytes(Charset.forName("UTF-8")).length);
if ((this.reserved2).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("reserved2", 2, (this.reserved2).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.graphicsExtendedSubHeader._root(), _root()))
throw new ConsistencyError("graphics_extended_sub_header", _root(), this.graphicsExtendedSubHeader._root());
if (!Objects.equals(this.graphicsExtendedSubHeader._parent(), this))
throw new ConsistencyError("graphics_extended_sub_header", this, this.graphicsExtendedSubHeader._parent());
_dirty = false;
}
private byte[] filePartTypeSy;
private String graphicId;
private String graphicName;
private Clasnfo graphicClassification;
private Encrypt encryption;
private byte[] graphicType;
private String reserved1;
private String graphicDisplayLevel;
private String graphicAttachmentLevel;
private String graphicLocation;
private String firstGraphicBoundLoc;
private String graphicColor;
private String secondGraphicBoundLoc;
private String reserved2;
private TreHeader graphicsExtendedSubHeader;
private Nitf _root;
private Nitf.GraphicsSegment _parent;
public byte[] filePartTypeSy() { return filePartTypeSy; }
public void setFilePartTypeSy(byte[] _v) { _dirty = true; filePartTypeSy = _v; }
public String graphicId() { return graphicId; }
public void setGraphicId(String _v) { _dirty = true; graphicId = _v; }
public String graphicName() { return graphicName; }
public void setGraphicName(String _v) { _dirty = true; graphicName = _v; }
public Clasnfo graphicClassification() { return graphicClassification; }
public void setGraphicClassification(Clasnfo _v) { _dirty = true; graphicClassification = _v; }
public Encrypt encryption() { return encryption; }
public void setEncryption(Encrypt _v) { _dirty = true; encryption = _v; }
public byte[] graphicType() { return graphicType; }
public void setGraphicType(byte[] _v) { _dirty = true; graphicType = _v; }
/**
* Reserved
*/
public String reserved1() { return reserved1; }
public void setReserved1(String _v) { _dirty = true; reserved1 = _v; }
public String graphicDisplayLevel() { return graphicDisplayLevel; }
public void setGraphicDisplayLevel(String _v) { _dirty = true; graphicDisplayLevel = _v; }
public String graphicAttachmentLevel() { return graphicAttachmentLevel; }
public void setGraphicAttachmentLevel(String _v) { _dirty = true; graphicAttachmentLevel = _v; }
public String graphicLocation() { return graphicLocation; }
public void setGraphicLocation(String _v) { _dirty = true; graphicLocation = _v; }
public String firstGraphicBoundLoc() { return firstGraphicBoundLoc; }
public void setFirstGraphicBoundLoc(String _v) { _dirty = true; firstGraphicBoundLoc = _v; }
public String graphicColor() { return graphicColor; }
public void setGraphicColor(String _v) { _dirty = true; graphicColor = _v; }
public String secondGraphicBoundLoc() { return secondGraphicBoundLoc; }
public void setSecondGraphicBoundLoc(String _v) { _dirty = true; secondGraphicBoundLoc = _v; }
/**
* Reserved
*/
public String reserved2() { return reserved2; }
public void setReserved2(String _v) { _dirty = true; reserved2 = _v; }
public TreHeader graphicsExtendedSubHeader() { return graphicsExtendedSubHeader; }
public void setGraphicsExtendedSubHeader(TreHeader _v) { _dirty = true; graphicsExtendedSubHeader = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.GraphicsSegment _parent() { return _parent; }
public void set_parent(Nitf.GraphicsSegment _v) { _dirty = true; _parent = _v; }
}
public static class GraphicsSegment extends KaitaiStruct.ReadWrite {
public GraphicsSegment(int idx) {
this(null, null, null, idx);
}
public GraphicsSegment(KaitaiStream _io, int idx) {
this(_io, null, null, idx);
}
public GraphicsSegment(KaitaiStream _io, Nitf _parent, int idx) {
this(_io, _parent, null, idx);
}
public GraphicsSegment(KaitaiStream _io, Nitf _parent, Nitf _root, int idx) {
super(_io);
this._parent = _parent;
this._root = _root;
this.idx = idx;
}
public void _read() {
this.graphicSubHeader = new GraphicSubHeader(this._io, this, _root);
this.graphicSubHeader._read();
this.graphicDataField = this._io.readBytes(Long.parseLong(_parent().header().lnnfo().get(((Number) (idx())).intValue()).lengthGraphicSegment(), 10));
_dirty = false;
}
public void _fetchInstances() {
this.graphicSubHeader._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
this.graphicSubHeader._write_Seq(this._io);
this._io.writeBytes(this.graphicDataField);
}
public void _check() {
if (!Objects.equals(this.graphicSubHeader._root(), _root()))
throw new ConsistencyError("graphic_sub_header", _root(), this.graphicSubHeader._root());
if (!Objects.equals(this.graphicSubHeader._parent(), this))
throw new ConsistencyError("graphic_sub_header", this, this.graphicSubHeader._parent());
if (this.graphicDataField.length != Long.parseLong(_parent().header().lnnfo().get(((Number) (idx())).intValue()).lengthGraphicSegment(), 10))
throw new ConsistencyError("graphic_data_field", Long.parseLong(_parent().header().lnnfo().get(((Number) (idx())).intValue()).lengthGraphicSegment(), 10), this.graphicDataField.length);
_dirty = false;
}
private GraphicSubHeader graphicSubHeader;
private byte[] graphicDataField;
private int idx;
private Nitf _root;
private Nitf _parent;
public GraphicSubHeader graphicSubHeader() { return graphicSubHeader; }
public void setGraphicSubHeader(GraphicSubHeader _v) { _dirty = true; graphicSubHeader = _v; }
public byte[] graphicDataField() { return graphicDataField; }
public void setGraphicDataField(byte[] _v) { _dirty = true; graphicDataField = _v; }
public int idx() { return idx; }
public void setIdx(int _v) { _dirty = true; idx = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf _parent() { return _parent; }
public void set_parent(Nitf _v) { _dirty = true; _parent = _v; }
}
public static class Header extends KaitaiStruct.ReadWrite {
public static Header fromFile(String fileName) throws IOException {
return new Header(new ByteBufferKaitaiStream(fileName));
}
public Header() {
this(null, null, null);
}
public Header(KaitaiStream _io) {
this(_io, null, null);
}
public Header(KaitaiStream _io, Nitf _parent) {
this(_io, _parent, null);
}
public Header(KaitaiStream _io, Nitf _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.fileProfileName = this._io.readBytes(4);
if (!(Arrays.equals(this.fileProfileName, new byte[] { 78, 73, 84, 70 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 78, 73, 84, 70 }, this.fileProfileName, this._io, "/types/header/seq/0");
}
this.fileVersion = this._io.readBytes(5);
if (!(Arrays.equals(this.fileVersion, new byte[] { 48, 50, 46, 49, 48 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 48, 50, 46, 49, 48 }, this.fileVersion, this._io, "/types/header/seq/1");
}
this.complexityLevel = this._io.readBytes(2);
this.standardType = this._io.readBytes(4);
if (!(Arrays.equals(this.standardType, new byte[] { 66, 70, 48, 49 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 66, 70, 48, 49 }, this.standardType, this._io, "/types/header/seq/3");
}
this.originatingStationId = new String(this._io.readBytes(10), StandardCharsets.UTF_8);
this.fileDateTime = new DateTime(this._io, this, _root);
this.fileDateTime._read();
this.fileTitle = new String(this._io.readBytes(80), StandardCharsets.UTF_8);
this.fileSecurity = new Clasnfo(this._io, this, _root);
this.fileSecurity._read();
this.fileCopyNumber = new String(this._io.readBytes(5), StandardCharsets.UTF_8);
this.fileNumOfCopys = new String(this._io.readBytes(5), StandardCharsets.UTF_8);
this.encryption = new Encrypt(this._io, this, _root);
this.encryption._read();
this.fileBgColor = this._io.readBytes(3);
this.originatorName = new String(this._io.readBytes(24), StandardCharsets.UTF_8);
this.originatorPhone = new String(this._io.readBytes(18), StandardCharsets.UTF_8);
this.fileLength = new String(this._io.readBytes(12), StandardCharsets.UTF_8);
this.fileHeaderLength = new String(this._io.readBytes(6), StandardCharsets.UTF_8);
this.numImageSegments = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.linfo = new ArrayList<LengthImageInfo>();
for (int i = 0; i < Long.parseLong(numImageSegments(), 10); i++) {
LengthImageInfo _t_linfo = new LengthImageInfo(this._io, this, _root);
try {
_t_linfo._read();
} finally {
this.linfo.add(_t_linfo);
}
}
this.numGraphicsSegments = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.lnnfo = new ArrayList<LengthGraphicInfo>();
for (int i = 0; i < Long.parseLong(numGraphicsSegments(), 10); i++) {
LengthGraphicInfo _t_lnnfo = new LengthGraphicInfo(this._io, this, _root);
try {
_t_lnnfo._read();
} finally {
this.lnnfo.add(_t_lnnfo);
}
}
this.reservedNumx = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.numTextFiles = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.ltnfo = new ArrayList<LengthTextInfo>();
for (int i = 0; i < Long.parseLong(numTextFiles(), 10); i++) {
LengthTextInfo _t_ltnfo = new LengthTextInfo(this._io, this, _root);
try {
_t_ltnfo._read();
} finally {
this.ltnfo.add(_t_ltnfo);
}
}
this.numDataExtension = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.ldnfo = new ArrayList<LengthDataInfo>();
for (int i = 0; i < Long.parseLong(numDataExtension(), 10); i++) {
LengthDataInfo _t_ldnfo = new LengthDataInfo(this._io, this, _root);
try {
_t_ldnfo._read();
} finally {
this.ldnfo.add(_t_ldnfo);
}
}
this.numReservedExtension = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.lrnfo = new ArrayList<LengthReservedInfo>();
for (int i = 0; i < Long.parseLong(numReservedExtension(), 10); i++) {
LengthReservedInfo _t_lrnfo = new LengthReservedInfo(this._io, this, _root);
try {
_t_lrnfo._read();
} finally {
this.lrnfo.add(_t_lrnfo);
}
}
this.userDefinedHeader = new TreHeader(this._io, this, _root);
this.userDefinedHeader._read();
this.extendedHeader = new TreHeader(this._io, this, _root);
this.extendedHeader._read();
_dirty = false;
}
public void _fetchInstances() {
this.fileDateTime._fetchInstances();
this.fileSecurity._fetchInstances();
this.encryption._fetchInstances();
for (int i = 0; i < this.linfo.size(); i++) {
this.linfo.get(((Number) (i)).intValue())._fetchInstances();
}
for (int i = 0; i < this.lnnfo.size(); i++) {
this.lnnfo.get(((Number) (i)).intValue())._fetchInstances();
}
for (int i = 0; i < this.ltnfo.size(); i++) {
this.ltnfo.get(((Number) (i)).intValue())._fetchInstances();
}
for (int i = 0; i < this.ldnfo.size(); i++) {
this.ldnfo.get(((Number) (i)).intValue())._fetchInstances();
}
for (int i = 0; i < this.lrnfo.size(); i++) {
this.lrnfo.get(((Number) (i)).intValue())._fetchInstances();
}
this.userDefinedHeader._fetchInstances();
this.extendedHeader._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes(this.fileProfileName);
this._io.writeBytes(this.fileVersion);
this._io.writeBytes(this.complexityLevel);
this._io.writeBytes(this.standardType);
this._io.writeBytes((this.originatingStationId).getBytes(Charset.forName("UTF-8")));
this.fileDateTime._write_Seq(this._io);
this._io.writeBytes((this.fileTitle).getBytes(Charset.forName("UTF-8")));
this.fileSecurity._write_Seq(this._io);
this._io.writeBytes((this.fileCopyNumber).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.fileNumOfCopys).getBytes(Charset.forName("UTF-8")));
this.encryption._write_Seq(this._io);
this._io.writeBytes(this.fileBgColor);
this._io.writeBytes((this.originatorName).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.originatorPhone).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.fileLength).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.fileHeaderLength).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numImageSegments).getBytes(Charset.forName("UTF-8")));
for (int i = 0; i < this.linfo.size(); i++) {
this.linfo.get(((Number) (i)).intValue())._write_Seq(this._io);
}
this._io.writeBytes((this.numGraphicsSegments).getBytes(Charset.forName("UTF-8")));
for (int i = 0; i < this.lnnfo.size(); i++) {
this.lnnfo.get(((Number) (i)).intValue())._write_Seq(this._io);
}
this._io.writeBytes((this.reservedNumx).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numTextFiles).getBytes(Charset.forName("UTF-8")));
for (int i = 0; i < this.ltnfo.size(); i++) {
this.ltnfo.get(((Number) (i)).intValue())._write_Seq(this._io);
}
this._io.writeBytes((this.numDataExtension).getBytes(Charset.forName("UTF-8")));
for (int i = 0; i < this.ldnfo.size(); i++) {
this.ldnfo.get(((Number) (i)).intValue())._write_Seq(this._io);
}
this._io.writeBytes((this.numReservedExtension).getBytes(Charset.forName("UTF-8")));
for (int i = 0; i < this.lrnfo.size(); i++) {
this.lrnfo.get(((Number) (i)).intValue())._write_Seq(this._io);
}
this.userDefinedHeader._write_Seq(this._io);
this.extendedHeader._write_Seq(this._io);
}
public void _check() {
if (this.fileProfileName.length != 4)
throw new ConsistencyError("file_profile_name", 4, this.fileProfileName.length);
if (!(Arrays.equals(this.fileProfileName, new byte[] { 78, 73, 84, 70 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 78, 73, 84, 70 }, this.fileProfileName, null, "/types/header/seq/0");
}
if (this.fileVersion.length != 5)
throw new ConsistencyError("file_version", 5, this.fileVersion.length);
if (!(Arrays.equals(this.fileVersion, new byte[] { 48, 50, 46, 49, 48 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 48, 50, 46, 49, 48 }, this.fileVersion, null, "/types/header/seq/1");
}
if (this.complexityLevel.length != 2)
throw new ConsistencyError("complexity_level", 2, this.complexityLevel.length);
if (this.standardType.length != 4)
throw new ConsistencyError("standard_type", 4, this.standardType.length);
if (!(Arrays.equals(this.standardType, new byte[] { 66, 70, 48, 49 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 66, 70, 48, 49 }, this.standardType, null, "/types/header/seq/3");
}
if ((this.originatingStationId).getBytes(Charset.forName("UTF-8")).length != 10)
throw new ConsistencyError("originating_station_id", 10, (this.originatingStationId).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.fileDateTime._root(), _root()))
throw new ConsistencyError("file_date_time", _root(), this.fileDateTime._root());
if (!Objects.equals(this.fileDateTime._parent(), this))
throw new ConsistencyError("file_date_time", this, this.fileDateTime._parent());
if ((this.fileTitle).getBytes(Charset.forName("UTF-8")).length != 80)
throw new ConsistencyError("file_title", 80, (this.fileTitle).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.fileSecurity._root(), _root()))
throw new ConsistencyError("file_security", _root(), this.fileSecurity._root());
if (!Objects.equals(this.fileSecurity._parent(), this))
throw new ConsistencyError("file_security", this, this.fileSecurity._parent());
if ((this.fileCopyNumber).getBytes(Charset.forName("UTF-8")).length != 5)
throw new ConsistencyError("file_copy_number", 5, (this.fileCopyNumber).getBytes(Charset.forName("UTF-8")).length);
if ((this.fileNumOfCopys).getBytes(Charset.forName("UTF-8")).length != 5)
throw new ConsistencyError("file_num_of_copys", 5, (this.fileNumOfCopys).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.encryption._root(), _root()))
throw new ConsistencyError("encryption", _root(), this.encryption._root());
if (!Objects.equals(this.encryption._parent(), this))
throw new ConsistencyError("encryption", this, this.encryption._parent());
if (this.fileBgColor.length != 3)
throw new ConsistencyError("file_bg_color", 3, this.fileBgColor.length);
if ((this.originatorName).getBytes(Charset.forName("UTF-8")).length != 24)
throw new ConsistencyError("originator_name", 24, (this.originatorName).getBytes(Charset.forName("UTF-8")).length);
if ((this.originatorPhone).getBytes(Charset.forName("UTF-8")).length != 18)
throw new ConsistencyError("originator_phone", 18, (this.originatorPhone).getBytes(Charset.forName("UTF-8")).length);
if ((this.fileLength).getBytes(Charset.forName("UTF-8")).length != 12)
throw new ConsistencyError("file_length", 12, (this.fileLength).getBytes(Charset.forName("UTF-8")).length);
if ((this.fileHeaderLength).getBytes(Charset.forName("UTF-8")).length != 6)
throw new ConsistencyError("file_header_length", 6, (this.fileHeaderLength).getBytes(Charset.forName("UTF-8")).length);
if ((this.numImageSegments).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("num_image_segments", 3, (this.numImageSegments).getBytes(Charset.forName("UTF-8")).length);
if (this.linfo.size() != Long.parseLong(numImageSegments(), 10))
throw new ConsistencyError("linfo", Long.parseLong(numImageSegments(), 10), this.linfo.size());
for (int i = 0; i < this.linfo.size(); i++) {
if (!Objects.equals(this.linfo.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("linfo", _root(), this.linfo.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.linfo.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("linfo", this, this.linfo.get(((Number) (i)).intValue())._parent());
}
if ((this.numGraphicsSegments).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("num_graphics_segments", 3, (this.numGraphicsSegments).getBytes(Charset.forName("UTF-8")).length);
if (this.lnnfo.size() != Long.parseLong(numGraphicsSegments(), 10))
throw new ConsistencyError("lnnfo", Long.parseLong(numGraphicsSegments(), 10), this.lnnfo.size());
for (int i = 0; i < this.lnnfo.size(); i++) {
if (!Objects.equals(this.lnnfo.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("lnnfo", _root(), this.lnnfo.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.lnnfo.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("lnnfo", this, this.lnnfo.get(((Number) (i)).intValue())._parent());
}
if ((this.reservedNumx).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("reserved_numx", 3, (this.reservedNumx).getBytes(Charset.forName("UTF-8")).length);
if ((this.numTextFiles).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("num_text_files", 3, (this.numTextFiles).getBytes(Charset.forName("UTF-8")).length);
if (this.ltnfo.size() != Long.parseLong(numTextFiles(), 10))
throw new ConsistencyError("ltnfo", Long.parseLong(numTextFiles(), 10), this.ltnfo.size());
for (int i = 0; i < this.ltnfo.size(); i++) {
if (!Objects.equals(this.ltnfo.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("ltnfo", _root(), this.ltnfo.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.ltnfo.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("ltnfo", this, this.ltnfo.get(((Number) (i)).intValue())._parent());
}
if ((this.numDataExtension).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("num_data_extension", 3, (this.numDataExtension).getBytes(Charset.forName("UTF-8")).length);
if (this.ldnfo.size() != Long.parseLong(numDataExtension(), 10))
throw new ConsistencyError("ldnfo", Long.parseLong(numDataExtension(), 10), this.ldnfo.size());
for (int i = 0; i < this.ldnfo.size(); i++) {
if (!Objects.equals(this.ldnfo.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("ldnfo", _root(), this.ldnfo.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.ldnfo.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("ldnfo", this, this.ldnfo.get(((Number) (i)).intValue())._parent());
}
if ((this.numReservedExtension).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("num_reserved_extension", 3, (this.numReservedExtension).getBytes(Charset.forName("UTF-8")).length);
if (this.lrnfo.size() != Long.parseLong(numReservedExtension(), 10))
throw new ConsistencyError("lrnfo", Long.parseLong(numReservedExtension(), 10), this.lrnfo.size());
for (int i = 0; i < this.lrnfo.size(); i++) {
if (!Objects.equals(this.lrnfo.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("lrnfo", _root(), this.lrnfo.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.lrnfo.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("lrnfo", this, this.lrnfo.get(((Number) (i)).intValue())._parent());
}
if (!Objects.equals(this.userDefinedHeader._root(), _root()))
throw new ConsistencyError("user_defined_header", _root(), this.userDefinedHeader._root());
if (!Objects.equals(this.userDefinedHeader._parent(), this))
throw new ConsistencyError("user_defined_header", this, this.userDefinedHeader._parent());
if (!Objects.equals(this.extendedHeader._root(), _root()))
throw new ConsistencyError("extended_header", _root(), this.extendedHeader._root());
if (!Objects.equals(this.extendedHeader._parent(), this))
throw new ConsistencyError("extended_header", this, this.extendedHeader._parent());
_dirty = false;
}
private byte[] fileProfileName;
private byte[] fileVersion;
private byte[] complexityLevel;
private byte[] standardType;
private String originatingStationId;
private DateTime fileDateTime;
private String fileTitle;
private Clasnfo fileSecurity;
private String fileCopyNumber;
private String fileNumOfCopys;
private Encrypt encryption;
private byte[] fileBgColor;
private String originatorName;
private String originatorPhone;
private String fileLength;
private String fileHeaderLength;
private String numImageSegments;
private List<LengthImageInfo> linfo;
private String numGraphicsSegments;
private List<LengthGraphicInfo> lnnfo;
private String reservedNumx;
private String numTextFiles;
private List<LengthTextInfo> ltnfo;
private String numDataExtension;
private List<LengthDataInfo> ldnfo;
private String numReservedExtension;
private List<LengthReservedInfo> lrnfo;
private TreHeader userDefinedHeader;
private TreHeader extendedHeader;
private Nitf _root;
private Nitf _parent;
public byte[] fileProfileName() { return fileProfileName; }
public void setFileProfileName(byte[] _v) { _dirty = true; fileProfileName = _v; }
public byte[] fileVersion() { return fileVersion; }
public void setFileVersion(byte[] _v) { _dirty = true; fileVersion = _v; }
public byte[] complexityLevel() { return complexityLevel; }
public void setComplexityLevel(byte[] _v) { _dirty = true; complexityLevel = _v; }
/**
* Value of BF01 indicates the file is formatted using ISO/IEC IS 12087-5.
*/
public byte[] standardType() { return standardType; }
public void setStandardType(byte[] _v) { _dirty = true; standardType = _v; }
public String originatingStationId() { return originatingStationId; }
public void setOriginatingStationId(String _v) { _dirty = true; originatingStationId = _v; }
public DateTime fileDateTime() { return fileDateTime; }
public void setFileDateTime(DateTime _v) { _dirty = true; fileDateTime = _v; }
public String fileTitle() { return fileTitle; }
public void setFileTitle(String _v) { _dirty = true; fileTitle = _v; }
public Clasnfo fileSecurity() { return fileSecurity; }
public void setFileSecurity(Clasnfo _v) { _dirty = true; fileSecurity = _v; }
public String fileCopyNumber() { return fileCopyNumber; }
public void setFileCopyNumber(String _v) { _dirty = true; fileCopyNumber = _v; }
public String fileNumOfCopys() { return fileNumOfCopys; }
public void setFileNumOfCopys(String _v) { _dirty = true; fileNumOfCopys = _v; }
public Encrypt encryption() { return encryption; }
public void setEncryption(Encrypt _v) { _dirty = true; encryption = _v; }
public byte[] fileBgColor() { return fileBgColor; }
public void setFileBgColor(byte[] _v) { _dirty = true; fileBgColor = _v; }
public String originatorName() { return originatorName; }
public void setOriginatorName(String _v) { _dirty = true; originatorName = _v; }
public String originatorPhone() { return originatorPhone; }
public void setOriginatorPhone(String _v) { _dirty = true; originatorPhone = _v; }
public String fileLength() { return fileLength; }
public void setFileLength(String _v) { _dirty = true; fileLength = _v; }
public String fileHeaderLength() { return fileHeaderLength; }
public void setFileHeaderLength(String _v) { _dirty = true; fileHeaderLength = _v; }
public String numImageSegments() { return numImageSegments; }
public void setNumImageSegments(String _v) { _dirty = true; numImageSegments = _v; }
public List<LengthImageInfo> linfo() { return linfo; }
public void setLinfo(List<LengthImageInfo> _v) { _dirty = true; linfo = _v; }
public String numGraphicsSegments() { return numGraphicsSegments; }
public void setNumGraphicsSegments(String _v) { _dirty = true; numGraphicsSegments = _v; }
public List<LengthGraphicInfo> lnnfo() { return lnnfo; }
public void setLnnfo(List<LengthGraphicInfo> _v) { _dirty = true; lnnfo = _v; }
public String reservedNumx() { return reservedNumx; }
public void setReservedNumx(String _v) { _dirty = true; reservedNumx = _v; }
public String numTextFiles() { return numTextFiles; }
public void setNumTextFiles(String _v) { _dirty = true; numTextFiles = _v; }
public List<LengthTextInfo> ltnfo() { return ltnfo; }
public void setLtnfo(List<LengthTextInfo> _v) { _dirty = true; ltnfo = _v; }
public String numDataExtension() { return numDataExtension; }
public void setNumDataExtension(String _v) { _dirty = true; numDataExtension = _v; }
public List<LengthDataInfo> ldnfo() { return ldnfo; }
public void setLdnfo(List<LengthDataInfo> _v) { _dirty = true; ldnfo = _v; }
public String numReservedExtension() { return numReservedExtension; }
public void setNumReservedExtension(String _v) { _dirty = true; numReservedExtension = _v; }
public List<LengthReservedInfo> lrnfo() { return lrnfo; }
public void setLrnfo(List<LengthReservedInfo> _v) { _dirty = true; lrnfo = _v; }
public TreHeader userDefinedHeader() { return userDefinedHeader; }
public void setUserDefinedHeader(TreHeader _v) { _dirty = true; userDefinedHeader = _v; }
public TreHeader extendedHeader() { return extendedHeader; }
public void setExtendedHeader(TreHeader _v) { _dirty = true; extendedHeader = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf _parent() { return _parent; }
public void set_parent(Nitf _v) { _dirty = true; _parent = _v; }
}
public static class ImageComment extends KaitaiStruct.ReadWrite {
public static ImageComment fromFile(String fileName) throws IOException {
return new ImageComment(new ByteBufferKaitaiStream(fileName));
}
public ImageComment() {
this(null, null, null);
}
public ImageComment(KaitaiStream _io) {
this(_io, null, null);
}
public ImageComment(KaitaiStream _io, Nitf.ImageSubHeader _parent) {
this(_io, _parent, null);
}
public ImageComment(KaitaiStream _io, Nitf.ImageSubHeader _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this._unnamed0 = new String(this._io.readBytes(80), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this._unnamed0).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this._unnamed0).getBytes(Charset.forName("UTF-8")).length != 80)
throw new ConsistencyError("_unnamed0", 80, (this._unnamed0).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String _unnamed0;
private Nitf _root;
private Nitf.ImageSubHeader _parent;
public String _unnamed0() { return _unnamed0; }
public void set_unnamed0(String _v) { _dirty = true; _unnamed0 = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.ImageSubHeader _parent() { return _parent; }
public void set_parent(Nitf.ImageSubHeader _v) { _dirty = true; _parent = _v; }
}
public static class ImageDataMask extends KaitaiStruct.ReadWrite {
public static ImageDataMask fromFile(String fileName) throws IOException {
return new ImageDataMask(new ByteBufferKaitaiStream(fileName));
}
public ImageDataMask() {
this(null, null, null);
}
public ImageDataMask(KaitaiStream _io) {
this(_io, null, null);
}
public ImageDataMask(KaitaiStream _io, Nitf.ImageSegment _parent) {
this(_io, _parent, null);
}
public ImageDataMask(KaitaiStream _io, Nitf.ImageSegment _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.blockedImgDataOffset = this._io.readU4be();
this.bmrlnth = this._io.readU2be();
this.tmrlnth = this._io.readU2be();
this.tpxcdlnth = this._io.readU2be();
this.tpxcd = this._io.readBytes(tpxcdSize());
if (hasBmr()) {
this.bmrbnd = new ArrayList<Long>();
for (int i = 0; i < bmrtmrCount(); i++) {
this.bmrbnd.add(this._io.readU4be());
}
}
if (hasTmr()) {
this.tmrbnd = new ArrayList<Long>();
for (int i = 0; i < bmrtmrCount(); i++) {
this.tmrbnd.add(this._io.readU4be());
}
}
_dirty = false;
}
public void _fetchInstances() {
if (hasBmr()) {
for (int i = 0; i < this.bmrbnd.size(); i++) {
}
}
if (hasTmr()) {
for (int i = 0; i < this.tmrbnd.size(); i++) {
}
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeU4be(this.blockedImgDataOffset);
this._io.writeU2be(this.bmrlnth);
this._io.writeU2be(this.tmrlnth);
this._io.writeU2be(this.tpxcdlnth);
this._io.writeBytes(this.tpxcd);
if (hasBmr()) {
for (int i = 0; i < this.bmrbnd.size(); i++) {
this._io.writeU4be(this.bmrbnd.get(((Number) (i)).intValue()));
}
}
if (hasTmr()) {
for (int i = 0; i < this.tmrbnd.size(); i++) {
this._io.writeU4be(this.tmrbnd.get(((Number) (i)).intValue()));
}
}
}
public void _check() {
if (this.tpxcd.length != tpxcdSize())
throw new ConsistencyError("tpxcd", tpxcdSize(), this.tpxcd.length);
if (hasBmr()) {
if (this.bmrbnd.size() != bmrtmrCount())
throw new ConsistencyError("bmrbnd", bmrtmrCount(), this.bmrbnd.size());
for (int i = 0; i < this.bmrbnd.size(); i++) {
}
}
if (hasTmr()) {
if (this.tmrbnd.size() != bmrtmrCount())
throw new ConsistencyError("tmrbnd", bmrtmrCount(), this.tmrbnd.size());
for (int i = 0; i < this.tmrbnd.size(); i++) {
}
}
_dirty = false;
}
private Integer bmrbndSize;
public Integer bmrbndSize() {
if (this.bmrbndSize != null)
return this.bmrbndSize;
this.bmrbndSize = ((Number) ((hasBmr() ? bmrtmrCount() * 4 : 0))).intValue();
return this.bmrbndSize;
}
public void _invalidateBmrbndSize() { this.bmrbndSize = null; }
private Integer bmrtmrCount;
public Integer bmrtmrCount() {
if (this.bmrtmrCount != null)
return this.bmrtmrCount;
this.bmrtmrCount = ((Number) ((Long.parseLong(_parent().imageSubHeader().numBlocksPerRow(), 10) * Long.parseLong(_parent().imageSubHeader().numBlocksPerCol(), 10)) * (!_parent().imageSubHeader().imgMode().equals("S") ? 1 : (Long.parseLong(_parent().imageSubHeader().numBands(), 10) != 0 ? Long.parseLong(_parent().imageSubHeader().numBands(), 10) : Long.parseLong(_parent().imageSubHeader().numMultispectralBands(), 10))))).intValue();
return this.bmrtmrCount;
}
public void _invalidateBmrtmrCount() { this.bmrtmrCount = null; }
private Boolean hasBmr;
public Boolean hasBmr() {
if (this.hasBmr != null)
return this.hasBmr;
this.hasBmr = bmrlnth() != 0;
return this.hasBmr;
}
public void _invalidateHasBmr() { this.hasBmr = null; }
private Boolean hasTmr;
public Boolean hasTmr() {
if (this.hasTmr != null)
return this.hasTmr;
this.hasTmr = tmrlnth() != 0;
return this.hasTmr;
}
public void _invalidateHasTmr() { this.hasTmr = null; }
private Integer tmrbndSize;
public Integer tmrbndSize() {
if (this.tmrbndSize != null)
return this.tmrbndSize;
this.tmrbndSize = ((Number) ((hasTmr() ? bmrtmrCount() * 4 : 0))).intValue();
return this.tmrbndSize;
}
public void _invalidateTmrbndSize() { this.tmrbndSize = null; }
private Integer totalSize;
public Integer totalSize() {
if (this.totalSize != null)
return this.totalSize;
this.totalSize = ((Number) ((((((4 + 2) + 2) + 2) + tpxcdSize()) + bmrbndSize()) + tmrbndSize())).intValue();
return this.totalSize;
}
public void _invalidateTotalSize() { this.totalSize = null; }
private Integer tpxcdSize;
public Integer tpxcdSize() {
if (this.tpxcdSize != null)
return this.tpxcdSize;
this.tpxcdSize = ((Number) ((KaitaiStream.mod(tpxcdlnth(), 8) == 0 ? tpxcdlnth() : tpxcdlnth() + (8 - KaitaiStream.mod(tpxcdlnth(), 8))) / 8)).intValue();
return this.tpxcdSize;
}
public void _invalidateTpxcdSize() { this.tpxcdSize = null; }
private long blockedImgDataOffset;
private int bmrlnth;
private int tmrlnth;
private int tpxcdlnth;
private byte[] tpxcd;
private List<Long> bmrbnd;
private List<Long> tmrbnd;
private Nitf _root;
private Nitf.ImageSegment _parent;
public long blockedImgDataOffset() { return blockedImgDataOffset; }
public void setBlockedImgDataOffset(long _v) { _dirty = true; blockedImgDataOffset = _v; }
/**
* Block Mask Record Length
*/
public int bmrlnth() { return bmrlnth; }
public void setBmrlnth(int _v) { _dirty = true; bmrlnth = _v; }
/**
* Pad Pixel Mask Record Length
*/
public int tmrlnth() { return tmrlnth; }
public void setTmrlnth(int _v) { _dirty = true; tmrlnth = _v; }
/**
* Pad Output Pixel Code Length
*/
public int tpxcdlnth() { return tpxcdlnth; }
public void setTpxcdlnth(int _v) { _dirty = true; tpxcdlnth = _v; }
/**
* Pad Output Pixel Code
*/
public byte[] tpxcd() { return tpxcd; }
public void setTpxcd(byte[] _v) { _dirty = true; tpxcd = _v; }
/**
* Block n, Band m Offset
*/
public List<Long> bmrbnd() { return bmrbnd; }
public void setBmrbnd(List<Long> _v) { _dirty = true; bmrbnd = _v; }
/**
* Pad Pixel n, Band m
*/
public List<Long> tmrbnd() { return tmrbnd; }
public void setTmrbnd(List<Long> _v) { _dirty = true; tmrbnd = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.ImageSegment _parent() { return _parent; }
public void set_parent(Nitf.ImageSegment _v) { _dirty = true; _parent = _v; }
}
public static class ImageSegment extends KaitaiStruct.ReadWrite {
public ImageSegment(int idx) {
this(null, null, null, idx);
}
public ImageSegment(KaitaiStream _io, int idx) {
this(_io, null, null, idx);
}
public ImageSegment(KaitaiStream _io, Nitf _parent, int idx) {
this(_io, _parent, null, idx);
}
public ImageSegment(KaitaiStream _io, Nitf _parent, Nitf _root, int idx) {
super(_io);
this._parent = _parent;
this._root = _root;
this.idx = idx;
}
public void _read() {
this.imageSubHeader = new ImageSubHeader(this._io, this, _root);
this.imageSubHeader._read();
if (hasMask()) {
this.imageDataMask = new ImageDataMask(this._io, this, _root);
this.imageDataMask._read();
}
if (hasMask()) {
this.imageDataField = this._io.readBytes(Long.parseLong(_parent().header().linfo().get(((Number) (idx())).intValue()).lengthImageSegment(), 10) - imageDataMask().totalSize());
}
_dirty = false;
}
public void _fetchInstances() {
this.imageSubHeader._fetchInstances();
if (hasMask()) {
this.imageDataMask._fetchInstances();
}
if (hasMask()) {
}
}
public void _write_Seq() {
_assertNotDirty();
this.imageSubHeader._write_Seq(this._io);
if (hasMask()) {
this.imageDataMask._write_Seq(this._io);
}
if (hasMask()) {
this._io.writeBytes(this.imageDataField);
}
}
public void _check() {
if (!Objects.equals(this.imageSubHeader._root(), _root()))
throw new ConsistencyError("image_sub_header", _root(), this.imageSubHeader._root());
if (!Objects.equals(this.imageSubHeader._parent(), this))
throw new ConsistencyError("image_sub_header", this, this.imageSubHeader._parent());
if (hasMask()) {
if (!Objects.equals(this.imageDataMask._root(), _root()))
throw new ConsistencyError("image_data_mask", _root(), this.imageDataMask._root());
if (!Objects.equals(this.imageDataMask._parent(), this))
throw new ConsistencyError("image_data_mask", this, this.imageDataMask._parent());
}
if (hasMask()) {
if (this.imageDataField.length != Long.parseLong(_parent().header().linfo().get(((Number) (idx())).intValue()).lengthImageSegment(), 10) - imageDataMask().totalSize())
throw new ConsistencyError("image_data_field", Long.parseLong(_parent().header().linfo().get(((Number) (idx())).intValue()).lengthImageSegment(), 10) - imageDataMask().totalSize(), this.imageDataField.length);
}
_dirty = false;
}
private Boolean hasMask;
public Boolean hasMask() {
if (this.hasMask != null)
return this.hasMask;
this.hasMask = imageSubHeader().imgCompression().substring(0, 2).equals("MM");
return this.hasMask;
}
public void _invalidateHasMask() { this.hasMask = null; }
private ImageSubHeader imageSubHeader;
private ImageDataMask imageDataMask;
private byte[] imageDataField;
private int idx;
private Nitf _root;
private Nitf _parent;
public ImageSubHeader imageSubHeader() { return imageSubHeader; }
public void setImageSubHeader(ImageSubHeader _v) { _dirty = true; imageSubHeader = _v; }
public ImageDataMask imageDataMask() { return imageDataMask; }
public void setImageDataMask(ImageDataMask _v) { _dirty = true; imageDataMask = _v; }
public byte[] imageDataField() { return imageDataField; }
public void setImageDataField(byte[] _v) { _dirty = true; imageDataField = _v; }
public int idx() { return idx; }
public void setIdx(int _v) { _dirty = true; idx = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf _parent() { return _parent; }
public void set_parent(Nitf _v) { _dirty = true; _parent = _v; }
}
public static class ImageSubHeader extends KaitaiStruct.ReadWrite {
public static ImageSubHeader fromFile(String fileName) throws IOException {
return new ImageSubHeader(new ByteBufferKaitaiStream(fileName));
}
public ImageSubHeader() {
this(null, null, null);
}
public ImageSubHeader(KaitaiStream _io) {
this(_io, null, null);
}
public ImageSubHeader(KaitaiStream _io, Nitf.ImageSegment _parent) {
this(_io, _parent, null);
}
public ImageSubHeader(KaitaiStream _io, Nitf.ImageSegment _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.filePartType = this._io.readBytes(2);
if (!(Arrays.equals(this.filePartType, new byte[] { 73, 77 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 73, 77 }, this.filePartType, this._io, "/types/image_sub_header/seq/0");
}
this.imageId1 = new String(this._io.readBytes(10), StandardCharsets.UTF_8);
this.imageDateTime = new DateTime(this._io, this, _root);
this.imageDateTime._read();
this.targetId = new String(this._io.readBytes(17), StandardCharsets.UTF_8);
this.imageId2 = new String(this._io.readBytes(80), StandardCharsets.UTF_8);
this.imageSecurityClassification = new Clasnfo(this._io, this, _root);
this.imageSecurityClassification._read();
this.encryption = new Encrypt(this._io, this, _root);
this.encryption._read();
this.imageSource = new String(this._io.readBytes(42), StandardCharsets.UTF_8);
this.numSigRows = new String(this._io.readBytes(8), StandardCharsets.UTF_8);
this.numSigCols = new String(this._io.readBytes(8), StandardCharsets.UTF_8);
this.pixelValueType = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.imageRepresentation = new String(this._io.readBytes(8), StandardCharsets.UTF_8);
this.imageCategory = new String(this._io.readBytes(8), StandardCharsets.UTF_8);
this.actualBitsPerPixelPerBand = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.pixelJustification = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.imageCoordinateRep = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.imageGeoLoc = new String(this._io.readBytes(60), StandardCharsets.UTF_8);
this.numImgComments = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.imgComments = new ArrayList<ImageComment>();
for (int i = 0; i < Long.parseLong(numImgComments(), 10); i++) {
ImageComment _t_imgComments = new ImageComment(this._io, this, _root);
try {
_t_imgComments._read();
} finally {
this.imgComments.add(_t_imgComments);
}
}
this.imgCompression = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.compressionRateCode = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.numBands = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
if (Long.parseLong(numBands(), 10) == 0) {
this.numMultispectralBands = new String(this._io.readBytes(5), StandardCharsets.UTF_8);
}
this.bands = new ArrayList<BandInfo>();
for (int i = 0; i < (Long.parseLong(numBands(), 10) != 0 ? Long.parseLong(numBands(), 10) : Long.parseLong(numMultispectralBands(), 10)); i++) {
BandInfo _t_bands = new BandInfo(this._io, this, _root);
try {
_t_bands._read();
} finally {
this.bands.add(_t_bands);
}
}
this.imgSyncCode = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.imgMode = new String(this._io.readBytes(1), StandardCharsets.UTF_8);
this.numBlocksPerRow = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.numBlocksPerCol = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.numPixelsPerBlockHorz = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.numPixelsPerBlockVert = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.numPixelsPerBand = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.imgDisplayLevel = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.attachmentLevel = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.imgLocation = new String(this._io.readBytes(10), StandardCharsets.UTF_8);
this.imgMagnification = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.userDefImgDataLen = new String(this._io.readBytes(5), StandardCharsets.UTF_8);
if (Long.parseLong(userDefImgDataLen(), 10) != 0) {
this.userDefOverflow = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
}
if (Long.parseLong(userDefImgDataLen(), 10) > 2) {
this.userDefImgData = new ArrayList<Integer>();
for (int i = 0; i < Long.parseLong(userDefImgDataLen(), 10) - 3; i++) {
this.userDefImgData.add(this._io.readU1());
}
}
this.imageExtendedSubHeader = new TreHeader(this._io, this, _root);
this.imageExtendedSubHeader._read();
_dirty = false;
}
public void _fetchInstances() {
this.imageDateTime._fetchInstances();
this.imageSecurityClassification._fetchInstances();
this.encryption._fetchInstances();
for (int i = 0; i < this.imgComments.size(); i++) {
this.imgComments.get(((Number) (i)).intValue())._fetchInstances();
}
if (Long.parseLong(numBands(), 10) == 0) {
}
for (int i = 0; i < this.bands.size(); i++) {
this.bands.get(((Number) (i)).intValue())._fetchInstances();
}
if (Long.parseLong(userDefImgDataLen(), 10) != 0) {
}
if (Long.parseLong(userDefImgDataLen(), 10) > 2) {
for (int i = 0; i < this.userDefImgData.size(); i++) {
}
}
this.imageExtendedSubHeader._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes(this.filePartType);
this._io.writeBytes((this.imageId1).getBytes(Charset.forName("UTF-8")));
this.imageDateTime._write_Seq(this._io);
this._io.writeBytes((this.targetId).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.imageId2).getBytes(Charset.forName("UTF-8")));
this.imageSecurityClassification._write_Seq(this._io);
this.encryption._write_Seq(this._io);
this._io.writeBytes((this.imageSource).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numSigRows).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numSigCols).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.pixelValueType).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.imageRepresentation).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.imageCategory).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.actualBitsPerPixelPerBand).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.pixelJustification).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.imageCoordinateRep).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.imageGeoLoc).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numImgComments).getBytes(Charset.forName("UTF-8")));
for (int i = 0; i < this.imgComments.size(); i++) {
this.imgComments.get(((Number) (i)).intValue())._write_Seq(this._io);
}
this._io.writeBytes((this.imgCompression).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.compressionRateCode).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numBands).getBytes(Charset.forName("UTF-8")));
if (Long.parseLong(numBands(), 10) == 0) {
this._io.writeBytes((this.numMultispectralBands).getBytes(Charset.forName("UTF-8")));
}
for (int i = 0; i < this.bands.size(); i++) {
this.bands.get(((Number) (i)).intValue())._write_Seq(this._io);
}
this._io.writeBytes((this.imgSyncCode).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.imgMode).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numBlocksPerRow).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numBlocksPerCol).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numPixelsPerBlockHorz).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numPixelsPerBlockVert).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.numPixelsPerBand).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.imgDisplayLevel).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.attachmentLevel).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.imgLocation).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.imgMagnification).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.userDefImgDataLen).getBytes(Charset.forName("UTF-8")));
if (Long.parseLong(userDefImgDataLen(), 10) != 0) {
this._io.writeBytes((this.userDefOverflow).getBytes(Charset.forName("UTF-8")));
}
if (Long.parseLong(userDefImgDataLen(), 10) > 2) {
for (int i = 0; i < this.userDefImgData.size(); i++) {
this._io.writeU1(this.userDefImgData.get(((Number) (i)).intValue()));
}
}
this.imageExtendedSubHeader._write_Seq(this._io);
}
public void _check() {
if (this.filePartType.length != 2)
throw new ConsistencyError("file_part_type", 2, this.filePartType.length);
if (!(Arrays.equals(this.filePartType, new byte[] { 73, 77 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 73, 77 }, this.filePartType, null, "/types/image_sub_header/seq/0");
}
if ((this.imageId1).getBytes(Charset.forName("UTF-8")).length != 10)
throw new ConsistencyError("image_id_1", 10, (this.imageId1).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.imageDateTime._root(), _root()))
throw new ConsistencyError("image_date_time", _root(), this.imageDateTime._root());
if (!Objects.equals(this.imageDateTime._parent(), this))
throw new ConsistencyError("image_date_time", this, this.imageDateTime._parent());
if ((this.targetId).getBytes(Charset.forName("UTF-8")).length != 17)
throw new ConsistencyError("target_id", 17, (this.targetId).getBytes(Charset.forName("UTF-8")).length);
if ((this.imageId2).getBytes(Charset.forName("UTF-8")).length != 80)
throw new ConsistencyError("image_id_2", 80, (this.imageId2).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.imageSecurityClassification._root(), _root()))
throw new ConsistencyError("image_security_classification", _root(), this.imageSecurityClassification._root());
if (!Objects.equals(this.imageSecurityClassification._parent(), this))
throw new ConsistencyError("image_security_classification", this, this.imageSecurityClassification._parent());
if (!Objects.equals(this.encryption._root(), _root()))
throw new ConsistencyError("encryption", _root(), this.encryption._root());
if (!Objects.equals(this.encryption._parent(), this))
throw new ConsistencyError("encryption", this, this.encryption._parent());
if ((this.imageSource).getBytes(Charset.forName("UTF-8")).length != 42)
throw new ConsistencyError("image_source", 42, (this.imageSource).getBytes(Charset.forName("UTF-8")).length);
if ((this.numSigRows).getBytes(Charset.forName("UTF-8")).length != 8)
throw new ConsistencyError("num_sig_rows", 8, (this.numSigRows).getBytes(Charset.forName("UTF-8")).length);
if ((this.numSigCols).getBytes(Charset.forName("UTF-8")).length != 8)
throw new ConsistencyError("num_sig_cols", 8, (this.numSigCols).getBytes(Charset.forName("UTF-8")).length);
if ((this.pixelValueType).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("pixel_value_type", 3, (this.pixelValueType).getBytes(Charset.forName("UTF-8")).length);
if ((this.imageRepresentation).getBytes(Charset.forName("UTF-8")).length != 8)
throw new ConsistencyError("image_representation", 8, (this.imageRepresentation).getBytes(Charset.forName("UTF-8")).length);
if ((this.imageCategory).getBytes(Charset.forName("UTF-8")).length != 8)
throw new ConsistencyError("image_category", 8, (this.imageCategory).getBytes(Charset.forName("UTF-8")).length);
if ((this.actualBitsPerPixelPerBand).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("actual_bits_per_pixel_per_band", 2, (this.actualBitsPerPixelPerBand).getBytes(Charset.forName("UTF-8")).length);
if ((this.pixelJustification).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("pixel_justification", 1, (this.pixelJustification).getBytes(Charset.forName("UTF-8")).length);
if ((this.imageCoordinateRep).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("image_coordinate_rep", 1, (this.imageCoordinateRep).getBytes(Charset.forName("UTF-8")).length);
if ((this.imageGeoLoc).getBytes(Charset.forName("UTF-8")).length != 60)
throw new ConsistencyError("image_geo_loc", 60, (this.imageGeoLoc).getBytes(Charset.forName("UTF-8")).length);
if ((this.numImgComments).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("num_img_comments", 1, (this.numImgComments).getBytes(Charset.forName("UTF-8")).length);
if (this.imgComments.size() != Long.parseLong(numImgComments(), 10))
throw new ConsistencyError("img_comments", Long.parseLong(numImgComments(), 10), this.imgComments.size());
for (int i = 0; i < this.imgComments.size(); i++) {
if (!Objects.equals(this.imgComments.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("img_comments", _root(), this.imgComments.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.imgComments.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("img_comments", this, this.imgComments.get(((Number) (i)).intValue())._parent());
}
if ((this.imgCompression).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("img_compression", 2, (this.imgCompression).getBytes(Charset.forName("UTF-8")).length);
if ((this.compressionRateCode).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("compression_rate_code", 4, (this.compressionRateCode).getBytes(Charset.forName("UTF-8")).length);
if ((this.numBands).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("num_bands", 1, (this.numBands).getBytes(Charset.forName("UTF-8")).length);
if (Long.parseLong(numBands(), 10) == 0) {
if ((this.numMultispectralBands).getBytes(Charset.forName("UTF-8")).length != 5)
throw new ConsistencyError("num_multispectral_bands", 5, (this.numMultispectralBands).getBytes(Charset.forName("UTF-8")).length);
}
if (this.bands.size() != (Long.parseLong(numBands(), 10) != 0 ? Long.parseLong(numBands(), 10) : Long.parseLong(numMultispectralBands(), 10)))
throw new ConsistencyError("bands", (Long.parseLong(numBands(), 10) != 0 ? Long.parseLong(numBands(), 10) : Long.parseLong(numMultispectralBands(), 10)), this.bands.size());
for (int i = 0; i < this.bands.size(); i++) {
if (!Objects.equals(this.bands.get(((Number) (i)).intValue())._root(), _root()))
throw new ConsistencyError("bands", _root(), this.bands.get(((Number) (i)).intValue())._root());
if (!Objects.equals(this.bands.get(((Number) (i)).intValue())._parent(), this))
throw new ConsistencyError("bands", this, this.bands.get(((Number) (i)).intValue())._parent());
}
if ((this.imgSyncCode).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("img_sync_code", 1, (this.imgSyncCode).getBytes(Charset.forName("UTF-8")).length);
if ((this.imgMode).getBytes(Charset.forName("UTF-8")).length != 1)
throw new ConsistencyError("img_mode", 1, (this.imgMode).getBytes(Charset.forName("UTF-8")).length);
if ((this.numBlocksPerRow).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("num_blocks_per_row", 4, (this.numBlocksPerRow).getBytes(Charset.forName("UTF-8")).length);
if ((this.numBlocksPerCol).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("num_blocks_per_col", 4, (this.numBlocksPerCol).getBytes(Charset.forName("UTF-8")).length);
if ((this.numPixelsPerBlockHorz).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("num_pixels_per_block_horz", 4, (this.numPixelsPerBlockHorz).getBytes(Charset.forName("UTF-8")).length);
if ((this.numPixelsPerBlockVert).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("num_pixels_per_block_vert", 4, (this.numPixelsPerBlockVert).getBytes(Charset.forName("UTF-8")).length);
if ((this.numPixelsPerBand).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("num_pixels_per_band", 2, (this.numPixelsPerBand).getBytes(Charset.forName("UTF-8")).length);
if ((this.imgDisplayLevel).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("img_display_level", 3, (this.imgDisplayLevel).getBytes(Charset.forName("UTF-8")).length);
if ((this.attachmentLevel).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("attachment_level", 3, (this.attachmentLevel).getBytes(Charset.forName("UTF-8")).length);
if ((this.imgLocation).getBytes(Charset.forName("UTF-8")).length != 10)
throw new ConsistencyError("img_location", 10, (this.imgLocation).getBytes(Charset.forName("UTF-8")).length);
if ((this.imgMagnification).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("img_magnification", 4, (this.imgMagnification).getBytes(Charset.forName("UTF-8")).length);
if ((this.userDefImgDataLen).getBytes(Charset.forName("UTF-8")).length != 5)
throw new ConsistencyError("user_def_img_data_len", 5, (this.userDefImgDataLen).getBytes(Charset.forName("UTF-8")).length);
if (Long.parseLong(userDefImgDataLen(), 10) != 0) {
if ((this.userDefOverflow).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("user_def_overflow", 3, (this.userDefOverflow).getBytes(Charset.forName("UTF-8")).length);
}
if (Long.parseLong(userDefImgDataLen(), 10) > 2) {
if (this.userDefImgData.size() != Long.parseLong(userDefImgDataLen(), 10) - 3)
throw new ConsistencyError("user_def_img_data", Long.parseLong(userDefImgDataLen(), 10) - 3, this.userDefImgData.size());
for (int i = 0; i < this.userDefImgData.size(); i++) {
}
}
if (!Objects.equals(this.imageExtendedSubHeader._root(), _root()))
throw new ConsistencyError("image_extended_sub_header", _root(), this.imageExtendedSubHeader._root());
if (!Objects.equals(this.imageExtendedSubHeader._parent(), this))
throw new ConsistencyError("image_extended_sub_header", this, this.imageExtendedSubHeader._parent());
_dirty = false;
}
private byte[] filePartType;
private String imageId1;
private DateTime imageDateTime;
private String targetId;
private String imageId2;
private Clasnfo imageSecurityClassification;
private Encrypt encryption;
private String imageSource;
private String numSigRows;
private String numSigCols;
private String pixelValueType;
private String imageRepresentation;
private String imageCategory;
private String actualBitsPerPixelPerBand;
private String pixelJustification;
private String imageCoordinateRep;
private String imageGeoLoc;
private String numImgComments;
private List<ImageComment> imgComments;
private String imgCompression;
private String compressionRateCode;
private String numBands;
private String numMultispectralBands;
private List<BandInfo> bands;
private String imgSyncCode;
private String imgMode;
private String numBlocksPerRow;
private String numBlocksPerCol;
private String numPixelsPerBlockHorz;
private String numPixelsPerBlockVert;
private String numPixelsPerBand;
private String imgDisplayLevel;
private String attachmentLevel;
private String imgLocation;
private String imgMagnification;
private String userDefImgDataLen;
private String userDefOverflow;
private List<Integer> userDefImgData;
private TreHeader imageExtendedSubHeader;
private Nitf _root;
private Nitf.ImageSegment _parent;
public byte[] filePartType() { return filePartType; }
public void setFilePartType(byte[] _v) { _dirty = true; filePartType = _v; }
public String imageId1() { return imageId1; }
public void setImageId1(String _v) { _dirty = true; imageId1 = _v; }
public DateTime imageDateTime() { return imageDateTime; }
public void setImageDateTime(DateTime _v) { _dirty = true; imageDateTime = _v; }
public String targetId() { return targetId; }
public void setTargetId(String _v) { _dirty = true; targetId = _v; }
public String imageId2() { return imageId2; }
public void setImageId2(String _v) { _dirty = true; imageId2 = _v; }
public Clasnfo imageSecurityClassification() { return imageSecurityClassification; }
public void setImageSecurityClassification(Clasnfo _v) { _dirty = true; imageSecurityClassification = _v; }
public Encrypt encryption() { return encryption; }
public void setEncryption(Encrypt _v) { _dirty = true; encryption = _v; }
public String imageSource() { return imageSource; }
public void setImageSource(String _v) { _dirty = true; imageSource = _v; }
/**
* Total number of rows of significant pixels in the image; only rows indexed 0 to (NROWS - 1) of the image contain significant data.
*/
public String numSigRows() { return numSigRows; }
public void setNumSigRows(String _v) { _dirty = true; numSigRows = _v; }
public String numSigCols() { return numSigCols; }
public void setNumSigCols(String _v) { _dirty = true; numSigCols = _v; }
public String pixelValueType() { return pixelValueType; }
public void setPixelValueType(String _v) { _dirty = true; pixelValueType = _v; }
/**
* MONO, RGB, RGB/LUT, MULTI, NODISPLY, NVECTOR, POLAR, VPH, YCbCr601
*/
public String imageRepresentation() { return imageRepresentation; }
public void setImageRepresentation(String _v) { _dirty = true; imageRepresentation = _v; }
/**
* VIS, SL, TI, FL, RD, EO, OP, HR, HS,CP, BP, SAR, SARIQ, IR, MAP, MS, FP, MRI, XRAY, CAT, VD, PAT, LEG, DTEM, MATR, LOCG, BARO, CURRENT, DEPTH, WIND
*/
public String imageCategory() { return imageCategory; }
public void setImageCategory(String _v) { _dirty = true; imageCategory = _v; }
public String actualBitsPerPixelPerBand() { return actualBitsPerPixelPerBand; }
public void setActualBitsPerPixelPerBand(String _v) { _dirty = true; actualBitsPerPixelPerBand = _v; }
public String pixelJustification() { return pixelJustification; }
public void setPixelJustification(String _v) { _dirty = true; pixelJustification = _v; }
public String imageCoordinateRep() { return imageCoordinateRep; }
public void setImageCoordinateRep(String _v) { _dirty = true; imageCoordinateRep = _v; }
public String imageGeoLoc() { return imageGeoLoc; }
public void setImageGeoLoc(String _v) { _dirty = true; imageGeoLoc = _v; }
public String numImgComments() { return numImgComments; }
public void setNumImgComments(String _v) { _dirty = true; numImgComments = _v; }
public List<ImageComment> imgComments() { return imgComments; }
public void setImgComments(List<ImageComment> _v) { _dirty = true; imgComments = _v; }
public String imgCompression() { return imgCompression; }
public void setImgCompression(String _v) { _dirty = true; imgCompression = _v; }
public String compressionRateCode() { return compressionRateCode; }
public void setCompressionRateCode(String _v) { _dirty = true; compressionRateCode = _v; }
public String numBands() { return numBands; }
public void setNumBands(String _v) { _dirty = true; numBands = _v; }
public String numMultispectralBands() { return numMultispectralBands; }
public void setNumMultispectralBands(String _v) { _dirty = true; numMultispectralBands = _v; }
public List<BandInfo> bands() { return bands; }
public void setBands(List<BandInfo> _v) { _dirty = true; bands = _v; }
/**
* Reserved for future use.
*/
public String imgSyncCode() { return imgSyncCode; }
public void setImgSyncCode(String _v) { _dirty = true; imgSyncCode = _v; }
/**
* B = Band Interleaved by Block, P = Band Interleaved by Pixel, R = Band Interleaved by Row, S = Band Sequential
*/
public String imgMode() { return imgMode; }
public void setImgMode(String _v) { _dirty = true; imgMode = _v; }
public String numBlocksPerRow() { return numBlocksPerRow; }
public void setNumBlocksPerRow(String _v) { _dirty = true; numBlocksPerRow = _v; }
public String numBlocksPerCol() { return numBlocksPerCol; }
public void setNumBlocksPerCol(String _v) { _dirty = true; numBlocksPerCol = _v; }
public String numPixelsPerBlockHorz() { return numPixelsPerBlockHorz; }
public void setNumPixelsPerBlockHorz(String _v) { _dirty = true; numPixelsPerBlockHorz = _v; }
public String numPixelsPerBlockVert() { return numPixelsPerBlockVert; }
public void setNumPixelsPerBlockVert(String _v) { _dirty = true; numPixelsPerBlockVert = _v; }
public String numPixelsPerBand() { return numPixelsPerBand; }
public void setNumPixelsPerBand(String _v) { _dirty = true; numPixelsPerBand = _v; }
public String imgDisplayLevel() { return imgDisplayLevel; }
public void setImgDisplayLevel(String _v) { _dirty = true; imgDisplayLevel = _v; }
public String attachmentLevel() { return attachmentLevel; }
public void setAttachmentLevel(String _v) { _dirty = true; attachmentLevel = _v; }
public String imgLocation() { return imgLocation; }
public void setImgLocation(String _v) { _dirty = true; imgLocation = _v; }
public String imgMagnification() { return imgMagnification; }
public void setImgMagnification(String _v) { _dirty = true; imgMagnification = _v; }
public String userDefImgDataLen() { return userDefImgDataLen; }
public void setUserDefImgDataLen(String _v) { _dirty = true; userDefImgDataLen = _v; }
public String userDefOverflow() { return userDefOverflow; }
public void setUserDefOverflow(String _v) { _dirty = true; userDefOverflow = _v; }
public List<Integer> userDefImgData() { return userDefImgData; }
public void setUserDefImgData(List<Integer> _v) { _dirty = true; userDefImgData = _v; }
public TreHeader imageExtendedSubHeader() { return imageExtendedSubHeader; }
public void setImageExtendedSubHeader(TreHeader _v) { _dirty = true; imageExtendedSubHeader = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.ImageSegment _parent() { return _parent; }
public void set_parent(Nitf.ImageSegment _v) { _dirty = true; _parent = _v; }
}
public static class LengthDataInfo extends KaitaiStruct.ReadWrite {
public static LengthDataInfo fromFile(String fileName) throws IOException {
return new LengthDataInfo(new ByteBufferKaitaiStream(fileName));
}
public LengthDataInfo() {
this(null, null, null);
}
public LengthDataInfo(KaitaiStream _io) {
this(_io, null, null);
}
public LengthDataInfo(KaitaiStream _io, Nitf.Header _parent) {
this(_io, _parent, null);
}
public LengthDataInfo(KaitaiStream _io, Nitf.Header _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.lengthDataExtensionSubheader = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.lengthDataExtensionSegment = new String(this._io.readBytes(9), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.lengthDataExtensionSubheader).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.lengthDataExtensionSegment).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this.lengthDataExtensionSubheader).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("length_data_extension_subheader", 4, (this.lengthDataExtensionSubheader).getBytes(Charset.forName("UTF-8")).length);
if ((this.lengthDataExtensionSegment).getBytes(Charset.forName("UTF-8")).length != 9)
throw new ConsistencyError("length_data_extension_segment", 9, (this.lengthDataExtensionSegment).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String lengthDataExtensionSubheader;
private String lengthDataExtensionSegment;
private Nitf _root;
private Nitf.Header _parent;
public String lengthDataExtensionSubheader() { return lengthDataExtensionSubheader; }
public void setLengthDataExtensionSubheader(String _v) { _dirty = true; lengthDataExtensionSubheader = _v; }
public String lengthDataExtensionSegment() { return lengthDataExtensionSegment; }
public void setLengthDataExtensionSegment(String _v) { _dirty = true; lengthDataExtensionSegment = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.Header _parent() { return _parent; }
public void set_parent(Nitf.Header _v) { _dirty = true; _parent = _v; }
}
public static class LengthGraphicInfo extends KaitaiStruct.ReadWrite {
public static LengthGraphicInfo fromFile(String fileName) throws IOException {
return new LengthGraphicInfo(new ByteBufferKaitaiStream(fileName));
}
public LengthGraphicInfo() {
this(null, null, null);
}
public LengthGraphicInfo(KaitaiStream _io) {
this(_io, null, null);
}
public LengthGraphicInfo(KaitaiStream _io, Nitf.Header _parent) {
this(_io, _parent, null);
}
public LengthGraphicInfo(KaitaiStream _io, Nitf.Header _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.lengthGraphicSubheader = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.lengthGraphicSegment = new String(this._io.readBytes(6), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.lengthGraphicSubheader).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.lengthGraphicSegment).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this.lengthGraphicSubheader).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("length_graphic_subheader", 4, (this.lengthGraphicSubheader).getBytes(Charset.forName("UTF-8")).length);
if ((this.lengthGraphicSegment).getBytes(Charset.forName("UTF-8")).length != 6)
throw new ConsistencyError("length_graphic_segment", 6, (this.lengthGraphicSegment).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String lengthGraphicSubheader;
private String lengthGraphicSegment;
private Nitf _root;
private Nitf.Header _parent;
public String lengthGraphicSubheader() { return lengthGraphicSubheader; }
public void setLengthGraphicSubheader(String _v) { _dirty = true; lengthGraphicSubheader = _v; }
public String lengthGraphicSegment() { return lengthGraphicSegment; }
public void setLengthGraphicSegment(String _v) { _dirty = true; lengthGraphicSegment = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.Header _parent() { return _parent; }
public void set_parent(Nitf.Header _v) { _dirty = true; _parent = _v; }
}
public static class LengthImageInfo extends KaitaiStruct.ReadWrite {
public static LengthImageInfo fromFile(String fileName) throws IOException {
return new LengthImageInfo(new ByteBufferKaitaiStream(fileName));
}
public LengthImageInfo() {
this(null, null, null);
}
public LengthImageInfo(KaitaiStream _io) {
this(_io, null, null);
}
public LengthImageInfo(KaitaiStream _io, Nitf.Header _parent) {
this(_io, _parent, null);
}
public LengthImageInfo(KaitaiStream _io, Nitf.Header _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.lengthImageSubheader = new String(this._io.readBytes(6), StandardCharsets.UTF_8);
this.lengthImageSegment = new String(this._io.readBytes(10), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.lengthImageSubheader).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.lengthImageSegment).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this.lengthImageSubheader).getBytes(Charset.forName("UTF-8")).length != 6)
throw new ConsistencyError("length_image_subheader", 6, (this.lengthImageSubheader).getBytes(Charset.forName("UTF-8")).length);
if ((this.lengthImageSegment).getBytes(Charset.forName("UTF-8")).length != 10)
throw new ConsistencyError("length_image_segment", 10, (this.lengthImageSegment).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String lengthImageSubheader;
private String lengthImageSegment;
private Nitf _root;
private Nitf.Header _parent;
public String lengthImageSubheader() { return lengthImageSubheader; }
public void setLengthImageSubheader(String _v) { _dirty = true; lengthImageSubheader = _v; }
public String lengthImageSegment() { return lengthImageSegment; }
public void setLengthImageSegment(String _v) { _dirty = true; lengthImageSegment = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.Header _parent() { return _parent; }
public void set_parent(Nitf.Header _v) { _dirty = true; _parent = _v; }
}
public static class LengthReservedInfo extends KaitaiStruct.ReadWrite {
public static LengthReservedInfo fromFile(String fileName) throws IOException {
return new LengthReservedInfo(new ByteBufferKaitaiStream(fileName));
}
public LengthReservedInfo() {
this(null, null, null);
}
public LengthReservedInfo(KaitaiStream _io) {
this(_io, null, null);
}
public LengthReservedInfo(KaitaiStream _io, Nitf.Header _parent) {
this(_io, _parent, null);
}
public LengthReservedInfo(KaitaiStream _io, Nitf.Header _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.lengthReservedExtensionSubheader = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.lengthReservedExtensionSegment = new String(this._io.readBytes(7), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.lengthReservedExtensionSubheader).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.lengthReservedExtensionSegment).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this.lengthReservedExtensionSubheader).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("length_reserved_extension_subheader", 4, (this.lengthReservedExtensionSubheader).getBytes(Charset.forName("UTF-8")).length);
if ((this.lengthReservedExtensionSegment).getBytes(Charset.forName("UTF-8")).length != 7)
throw new ConsistencyError("length_reserved_extension_segment", 7, (this.lengthReservedExtensionSegment).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String lengthReservedExtensionSubheader;
private String lengthReservedExtensionSegment;
private Nitf _root;
private Nitf.Header _parent;
public String lengthReservedExtensionSubheader() { return lengthReservedExtensionSubheader; }
public void setLengthReservedExtensionSubheader(String _v) { _dirty = true; lengthReservedExtensionSubheader = _v; }
public String lengthReservedExtensionSegment() { return lengthReservedExtensionSegment; }
public void setLengthReservedExtensionSegment(String _v) { _dirty = true; lengthReservedExtensionSegment = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.Header _parent() { return _parent; }
public void set_parent(Nitf.Header _v) { _dirty = true; _parent = _v; }
}
public static class LengthTextInfo extends KaitaiStruct.ReadWrite {
public static LengthTextInfo fromFile(String fileName) throws IOException {
return new LengthTextInfo(new ByteBufferKaitaiStream(fileName));
}
public LengthTextInfo() {
this(null, null, null);
}
public LengthTextInfo(KaitaiStream _io) {
this(_io, null, null);
}
public LengthTextInfo(KaitaiStream _io, Nitf.Header _parent) {
this(_io, _parent, null);
}
public LengthTextInfo(KaitaiStream _io, Nitf.Header _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.lengthTextSubheader = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.lengthTextSegment = new String(this._io.readBytes(5), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.lengthTextSubheader).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.lengthTextSegment).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this.lengthTextSubheader).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("length_text_subheader", 4, (this.lengthTextSubheader).getBytes(Charset.forName("UTF-8")).length);
if ((this.lengthTextSegment).getBytes(Charset.forName("UTF-8")).length != 5)
throw new ConsistencyError("length_text_segment", 5, (this.lengthTextSegment).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String lengthTextSubheader;
private String lengthTextSegment;
private Nitf _root;
private Nitf.Header _parent;
public String lengthTextSubheader() { return lengthTextSubheader; }
public void setLengthTextSubheader(String _v) { _dirty = true; lengthTextSubheader = _v; }
public String lengthTextSegment() { return lengthTextSegment; }
public void setLengthTextSegment(String _v) { _dirty = true; lengthTextSegment = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.Header _parent() { return _parent; }
public void set_parent(Nitf.Header _v) { _dirty = true; _parent = _v; }
}
public static class ReservedExtensionSegment extends KaitaiStruct.ReadWrite {
public ReservedExtensionSegment(int idx) {
this(null, null, null, idx);
}
public ReservedExtensionSegment(KaitaiStream _io, int idx) {
this(_io, null, null, idx);
}
public ReservedExtensionSegment(KaitaiStream _io, Nitf _parent, int idx) {
this(_io, _parent, null, idx);
}
public ReservedExtensionSegment(KaitaiStream _io, Nitf _parent, Nitf _root, int idx) {
super(_io);
this._parent = _parent;
this._root = _root;
this.idx = idx;
}
public void _read() {
this._raw_reservedSubHeader = this._io.readBytes(Long.parseLong(_parent().header().lrnfo().get(((Number) (idx())).intValue()).lengthReservedExtensionSubheader(), 10));
KaitaiStream _io__raw_reservedSubHeader = new ByteBufferKaitaiStream(this._raw_reservedSubHeader);
this.reservedSubHeader = new ReservedSubHeader(_io__raw_reservedSubHeader, this, _root);
this.reservedSubHeader._read();
this.reservedDataField = this._io.readBytes(Long.parseLong(_parent().header().lrnfo().get(((Number) (idx())).intValue()).lengthReservedExtensionSegment(), 10));
_dirty = false;
}
public void _fetchInstances() {
this.reservedSubHeader._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
final KaitaiStream _io__raw_reservedSubHeader = new ByteBufferKaitaiStream(Long.parseLong(_parent().header().lrnfo().get(((Number) (idx())).intValue()).lengthReservedExtensionSubheader(), 10));
this._io.addChildStream(_io__raw_reservedSubHeader);
{
long _pos2 = this._io.pos();
this._io.seek(this._io.pos() + (Long.parseLong(_parent().header().lrnfo().get(((Number) (idx())).intValue()).lengthReservedExtensionSubheader(), 10)));
final ReservedExtensionSegment _this = this;
_io__raw_reservedSubHeader.setWriteBackHandler(new KaitaiStream.WriteBackHandler(_pos2) {
@Override
protected void write(KaitaiStream parent) {
_this._raw_reservedSubHeader = _io__raw_reservedSubHeader.toByteArray();
if (_this._raw_reservedSubHeader.length != Long.parseLong(_parent().header().lrnfo().get(((Number) (idx())).intValue()).lengthReservedExtensionSubheader(), 10))
throw new ConsistencyError("raw(reserved_sub_header)", Long.parseLong(_parent().header().lrnfo().get(((Number) (idx())).intValue()).lengthReservedExtensionSubheader(), 10), _this._raw_reservedSubHeader.length);
parent.writeBytes(_this._raw_reservedSubHeader);
}
});
}
this.reservedSubHeader._write_Seq(_io__raw_reservedSubHeader);
this._io.writeBytes(this.reservedDataField);
}
public void _check() {
if (!Objects.equals(this.reservedSubHeader._root(), _root()))
throw new ConsistencyError("reserved_sub_header", _root(), this.reservedSubHeader._root());
if (!Objects.equals(this.reservedSubHeader._parent(), this))
throw new ConsistencyError("reserved_sub_header", this, this.reservedSubHeader._parent());
if (this.reservedDataField.length != Long.parseLong(_parent().header().lrnfo().get(((Number) (idx())).intValue()).lengthReservedExtensionSegment(), 10))
throw new ConsistencyError("reserved_data_field", Long.parseLong(_parent().header().lrnfo().get(((Number) (idx())).intValue()).lengthReservedExtensionSegment(), 10), this.reservedDataField.length);
_dirty = false;
}
private ReservedSubHeader reservedSubHeader;
private byte[] reservedDataField;
private int idx;
private Nitf _root;
private Nitf _parent;
private byte[] _raw_reservedSubHeader;
public ReservedSubHeader reservedSubHeader() { return reservedSubHeader; }
public void setReservedSubHeader(ReservedSubHeader _v) { _dirty = true; reservedSubHeader = _v; }
public byte[] reservedDataField() { return reservedDataField; }
public void setReservedDataField(byte[] _v) { _dirty = true; reservedDataField = _v; }
public int idx() { return idx; }
public void setIdx(int _v) { _dirty = true; idx = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf _parent() { return _parent; }
public void set_parent(Nitf _v) { _dirty = true; _parent = _v; }
public byte[] _raw_reservedSubHeader() { return _raw_reservedSubHeader; }
public void set_raw_ReservedSubHeader(byte[] _v) { _dirty = true; _raw_reservedSubHeader = _v; }
}
public static class ReservedSubHeader extends KaitaiStruct.ReadWrite {
public static ReservedSubHeader fromFile(String fileName) throws IOException {
return new ReservedSubHeader(new ByteBufferKaitaiStream(fileName));
}
public ReservedSubHeader() {
this(null, null, null);
}
public ReservedSubHeader(KaitaiStream _io) {
this(_io, null, null);
}
public ReservedSubHeader(KaitaiStream _io, Nitf.ReservedExtensionSegment _parent) {
this(_io, _parent, null);
}
public ReservedSubHeader(KaitaiStream _io, Nitf.ReservedExtensionSegment _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.filePartTypeRe = this._io.readBytes(2);
if (!(Arrays.equals(this.filePartTypeRe, new byte[] { 82, 69 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 82, 69 }, this.filePartTypeRe, this._io, "/types/reserved_sub_header/seq/0");
}
this.resTypeId = new String(this._io.readBytes(25), StandardCharsets.UTF_8);
this.resVersion = new String(this._io.readBytes(2), StandardCharsets.UTF_8);
this.reclasnfo = new Clasnfo(this._io, this, _root);
this.reclasnfo._read();
this.resUserDefinedSubheaderLength = new String(this._io.readBytes(4), StandardCharsets.UTF_8);
this.resUserDefinedSubheaderFields = new String(this._io.readBytes(Long.parseLong(resUserDefinedSubheaderLength(), 10)), StandardCharsets.UTF_8);
this.resUserDefinedData = new String(this._io.readBytesFull(), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
this.reclasnfo._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes(this.filePartTypeRe);
this._io.writeBytes((this.resTypeId).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.resVersion).getBytes(Charset.forName("UTF-8")));
this.reclasnfo._write_Seq(this._io);
this._io.writeBytes((this.resUserDefinedSubheaderLength).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.resUserDefinedSubheaderFields).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.resUserDefinedData).getBytes(Charset.forName("UTF-8")));
if (!(this._io.isEof()))
throw new ConsistencyError("res_user_defined_data", 0, this._io.size() - this._io.pos());
}
public void _check() {
if (this.filePartTypeRe.length != 2)
throw new ConsistencyError("file_part_type_re", 2, this.filePartTypeRe.length);
if (!(Arrays.equals(this.filePartTypeRe, new byte[] { 82, 69 }))) {
throw new KaitaiStream.ValidationNotEqualError(new byte[] { 82, 69 }, this.filePartTypeRe, null, "/types/reserved_sub_header/seq/0");
}
if ((this.resTypeId).getBytes(Charset.forName("UTF-8")).length != 25)
throw new ConsistencyError("res_type_id", 25, (this.resTypeId).getBytes(Charset.forName("UTF-8")).length);
if ((this.resVersion).getBytes(Charset.forName("UTF-8")).length != 2)
throw new ConsistencyError("res_version", 2, (this.resVersion).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.reclasnfo._root(), _root()))
throw new ConsistencyError("reclasnfo", _root(), this.reclasnfo._root());
if (!Objects.equals(this.reclasnfo._parent(), this))
throw new ConsistencyError("reclasnfo", this, this.reclasnfo._parent());
if ((this.resUserDefinedSubheaderLength).getBytes(Charset.forName("UTF-8")).length != 4)
throw new ConsistencyError("res_user_defined_subheader_length", 4, (this.resUserDefinedSubheaderLength).getBytes(Charset.forName("UTF-8")).length);
if ((this.resUserDefinedSubheaderFields).getBytes(Charset.forName("UTF-8")).length != Long.parseLong(resUserDefinedSubheaderLength(), 10))
throw new ConsistencyError("res_user_defined_subheader_fields", Long.parseLong(resUserDefinedSubheaderLength(), 10), (this.resUserDefinedSubheaderFields).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private byte[] filePartTypeRe;
private String resTypeId;
private String resVersion;
private Clasnfo reclasnfo;
private String resUserDefinedSubheaderLength;
private String resUserDefinedSubheaderFields;
private String resUserDefinedData;
private Nitf _root;
private Nitf.ReservedExtensionSegment _parent;
public byte[] filePartTypeRe() { return filePartTypeRe; }
public void setFilePartTypeRe(byte[] _v) { _dirty = true; filePartTypeRe = _v; }
public String resTypeId() { return resTypeId; }
public void setResTypeId(String _v) { _dirty = true; resTypeId = _v; }
public String resVersion() { return resVersion; }
public void setResVersion(String _v) { _dirty = true; resVersion = _v; }
public Clasnfo reclasnfo() { return reclasnfo; }
public void setReclasnfo(Clasnfo _v) { _dirty = true; reclasnfo = _v; }
public String resUserDefinedSubheaderLength() { return resUserDefinedSubheaderLength; }
public void setResUserDefinedSubheaderLength(String _v) { _dirty = true; resUserDefinedSubheaderLength = _v; }
public String resUserDefinedSubheaderFields() { return resUserDefinedSubheaderFields; }
public void setResUserDefinedSubheaderFields(String _v) { _dirty = true; resUserDefinedSubheaderFields = _v; }
public String resUserDefinedData() { return resUserDefinedData; }
public void setResUserDefinedData(String _v) { _dirty = true; resUserDefinedData = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf.ReservedExtensionSegment _parent() { return _parent; }
public void set_parent(Nitf.ReservedExtensionSegment _v) { _dirty = true; _parent = _v; }
}
public static class TextSegment extends KaitaiStruct.ReadWrite {
public TextSegment(int idx) {
this(null, null, null, idx);
}
public TextSegment(KaitaiStream _io, int idx) {
this(_io, null, null, idx);
}
public TextSegment(KaitaiStream _io, Nitf _parent, int idx) {
this(_io, _parent, null, idx);
}
public TextSegment(KaitaiStream _io, Nitf _parent, Nitf _root, int idx) {
super(_io);
this._parent = _parent;
this._root = _root;
this.idx = idx;
}
public void _read() {
this.textSubHeader = this._io.readBytes(1);
this.textDataField = this._io.readBytes(Long.parseLong(_parent().header().ltnfo().get(((Number) (idx())).intValue()).lengthTextSegment(), 10));
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes(this.textSubHeader);
this._io.writeBytes(this.textDataField);
}
public void _check() {
if (this.textSubHeader.length != 1)
throw new ConsistencyError("text_sub_header", 1, this.textSubHeader.length);
if (this.textDataField.length != Long.parseLong(_parent().header().ltnfo().get(((Number) (idx())).intValue()).lengthTextSegment(), 10))
throw new ConsistencyError("text_data_field", Long.parseLong(_parent().header().ltnfo().get(((Number) (idx())).intValue()).lengthTextSegment(), 10), this.textDataField.length);
_dirty = false;
}
private byte[] textSubHeader;
private byte[] textDataField;
private int idx;
private Nitf _root;
private Nitf _parent;
public byte[] textSubHeader() { return textSubHeader; }
public void setTextSubHeader(byte[] _v) { _dirty = true; textSubHeader = _v; }
public byte[] textDataField() { return textDataField; }
public void setTextDataField(byte[] _v) { _dirty = true; textDataField = _v; }
public int idx() { return idx; }
public void setIdx(int _v) { _dirty = true; idx = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public Nitf _parent() { return _parent; }
public void set_parent(Nitf _v) { _dirty = true; _parent = _v; }
}
public static class TextSubHeader extends KaitaiStruct.ReadWrite {
public static TextSubHeader fromFile(String fileName) throws IOException {
return new TextSubHeader(new ByteBufferKaitaiStream(fileName));
}
public TextSubHeader() {
this(null, null, null);
}
public TextSubHeader(KaitaiStream _io) {
this(_io, null, null);
}
public TextSubHeader(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public TextSubHeader(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.textDateTime = new String(this._io.readBytes(14), StandardCharsets.UTF_8);
this.textTitle = new String(this._io.readBytes(80), StandardCharsets.UTF_8);
this.textSecurityClass = new Clasnfo(this._io, this, _root);
this.textSecurityClass._read();
this.encryp = new Encrypt(this._io, this, _root);
this.encryp._read();
this.textFormat = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
this.textExtendedSubHeader = new TreHeader(this._io, this, _root);
this.textExtendedSubHeader._read();
_dirty = false;
}
public void _fetchInstances() {
this.textSecurityClass._fetchInstances();
this.encryp._fetchInstances();
this.textExtendedSubHeader._fetchInstances();
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.textDateTime).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.textTitle).getBytes(Charset.forName("UTF-8")));
this.textSecurityClass._write_Seq(this._io);
this.encryp._write_Seq(this._io);
this._io.writeBytes((this.textFormat).getBytes(Charset.forName("UTF-8")));
this.textExtendedSubHeader._write_Seq(this._io);
}
public void _check() {
if ((this.textDateTime).getBytes(Charset.forName("UTF-8")).length != 14)
throw new ConsistencyError("text_date_time", 14, (this.textDateTime).getBytes(Charset.forName("UTF-8")).length);
if ((this.textTitle).getBytes(Charset.forName("UTF-8")).length != 80)
throw new ConsistencyError("text_title", 80, (this.textTitle).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.textSecurityClass._root(), _root()))
throw new ConsistencyError("text_security_class", _root(), this.textSecurityClass._root());
if (!Objects.equals(this.textSecurityClass._parent(), this))
throw new ConsistencyError("text_security_class", this, this.textSecurityClass._parent());
if (!Objects.equals(this.encryp._root(), _root()))
throw new ConsistencyError("encryp", _root(), this.encryp._root());
if (!Objects.equals(this.encryp._parent(), this))
throw new ConsistencyError("encryp", this, this.encryp._parent());
if ((this.textFormat).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("text_format", 3, (this.textFormat).getBytes(Charset.forName("UTF-8")).length);
if (!Objects.equals(this.textExtendedSubHeader._root(), _root()))
throw new ConsistencyError("text_extended_sub_header", _root(), this.textExtendedSubHeader._root());
if (!Objects.equals(this.textExtendedSubHeader._parent(), this))
throw new ConsistencyError("text_extended_sub_header", this, this.textExtendedSubHeader._parent());
_dirty = false;
}
private String textDateTime;
private String textTitle;
private Clasnfo textSecurityClass;
private Encrypt encryp;
private String textFormat;
private TreHeader textExtendedSubHeader;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
public String textDateTime() { return textDateTime; }
public void setTextDateTime(String _v) { _dirty = true; textDateTime = _v; }
public String textTitle() { return textTitle; }
public void setTextTitle(String _v) { _dirty = true; textTitle = _v; }
public Clasnfo textSecurityClass() { return textSecurityClass; }
public void setTextSecurityClass(Clasnfo _v) { _dirty = true; textSecurityClass = _v; }
public Encrypt encryp() { return encryp; }
public void setEncryp(Encrypt _v) { _dirty = true; encryp = _v; }
/**
* MTF (USMTF see MIL-STD-6040), STA (indicates BCS), UT1 (indicates ECS), U8S
*/
public String textFormat() { return textFormat; }
public void setTextFormat(String _v) { _dirty = true; textFormat = _v; }
public TreHeader textExtendedSubHeader() { return textExtendedSubHeader; }
public void setTextExtendedSubHeader(TreHeader _v) { _dirty = true; textExtendedSubHeader = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class Tre extends KaitaiStruct.ReadWrite {
public static Tre fromFile(String fileName) throws IOException {
return new Tre(new ByteBufferKaitaiStream(fileName));
}
public Tre() {
this(null, null, null);
}
public Tre(KaitaiStream _io) {
this(_io, null, null);
}
public Tre(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public Tre(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.extensionTypeId = new String(this._io.readBytes(6), StandardCharsets.UTF_8);
this.edataLength = new String(this._io.readBytes(5), StandardCharsets.UTF_8);
this.edata = new String(this._io.readBytes(Long.parseLong(edataLength(), 10)), StandardCharsets.UTF_8);
_dirty = false;
}
public void _fetchInstances() {
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.extensionTypeId).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.edataLength).getBytes(Charset.forName("UTF-8")));
this._io.writeBytes((this.edata).getBytes(Charset.forName("UTF-8")));
}
public void _check() {
if ((this.extensionTypeId).getBytes(Charset.forName("UTF-8")).length != 6)
throw new ConsistencyError("extension_type_id", 6, (this.extensionTypeId).getBytes(Charset.forName("UTF-8")).length);
if ((this.edataLength).getBytes(Charset.forName("UTF-8")).length != 5)
throw new ConsistencyError("edata_length", 5, (this.edataLength).getBytes(Charset.forName("UTF-8")).length);
if ((this.edata).getBytes(Charset.forName("UTF-8")).length != Long.parseLong(edataLength(), 10))
throw new ConsistencyError("edata", Long.parseLong(edataLength(), 10), (this.edata).getBytes(Charset.forName("UTF-8")).length);
_dirty = false;
}
private String extensionTypeId;
private String edataLength;
private String edata;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
/**
* RETAG or CETAG
*/
public String extensionTypeId() { return extensionTypeId; }
public void setExtensionTypeId(String _v) { _dirty = true; extensionTypeId = _v; }
/**
* REL or CEL
*/
public String edataLength() { return edataLength; }
public void setEdataLength(String _v) { _dirty = true; edataLength = _v; }
/**
* REDATA or CEDATA
*/
public String edata() { return edata; }
public void setEdata(String _v) { _dirty = true; edata = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
public static class TreHeader extends KaitaiStruct.ReadWrite {
public static TreHeader fromFile(String fileName) throws IOException {
return new TreHeader(new ByteBufferKaitaiStream(fileName));
}
public TreHeader() {
this(null, null, null);
}
public TreHeader(KaitaiStream _io) {
this(_io, null, null);
}
public TreHeader(KaitaiStream _io, KaitaiStruct.ReadWrite _parent) {
this(_io, _parent, null);
}
public TreHeader(KaitaiStream _io, KaitaiStruct.ReadWrite _parent, Nitf _root) {
super(_io);
this._parent = _parent;
this._root = _root;
}
public void _read() {
this.headerDataLength = new String(this._io.readBytes(5), StandardCharsets.UTF_8);
if (Long.parseLong(headerDataLength(), 10) != 0) {
this.headerOverflow = new String(this._io.readBytes(3), StandardCharsets.UTF_8);
}
if (Long.parseLong(headerDataLength(), 10) > 2) {
this.headerData = new ArrayList<Integer>();
for (int i = 0; i < Long.parseLong(headerDataLength(), 10) - 3; i++) {
this.headerData.add(this._io.readU1());
}
}
_dirty = false;
}
public void _fetchInstances() {
if (Long.parseLong(headerDataLength(), 10) != 0) {
}
if (Long.parseLong(headerDataLength(), 10) > 2) {
for (int i = 0; i < this.headerData.size(); i++) {
}
}
}
public void _write_Seq() {
_assertNotDirty();
this._io.writeBytes((this.headerDataLength).getBytes(Charset.forName("UTF-8")));
if (Long.parseLong(headerDataLength(), 10) != 0) {
this._io.writeBytes((this.headerOverflow).getBytes(Charset.forName("UTF-8")));
}
if (Long.parseLong(headerDataLength(), 10) > 2) {
for (int i = 0; i < this.headerData.size(); i++) {
this._io.writeU1(this.headerData.get(((Number) (i)).intValue()));
}
}
}
public void _check() {
if ((this.headerDataLength).getBytes(Charset.forName("UTF-8")).length != 5)
throw new ConsistencyError("header_data_length", 5, (this.headerDataLength).getBytes(Charset.forName("UTF-8")).length);
if (Long.parseLong(headerDataLength(), 10) != 0) {
if ((this.headerOverflow).getBytes(Charset.forName("UTF-8")).length != 3)
throw new ConsistencyError("header_overflow", 3, (this.headerOverflow).getBytes(Charset.forName("UTF-8")).length);
}
if (Long.parseLong(headerDataLength(), 10) > 2) {
if (this.headerData.size() != Long.parseLong(headerDataLength(), 10) - 3)
throw new ConsistencyError("header_data", Long.parseLong(headerDataLength(), 10) - 3, this.headerData.size());
for (int i = 0; i < this.headerData.size(); i++) {
}
}
_dirty = false;
}
private String headerDataLength;
private String headerOverflow;
private List<Integer> headerData;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
public String headerDataLength() { return headerDataLength; }
public void setHeaderDataLength(String _v) { _dirty = true; headerDataLength = _v; }
public String headerOverflow() { return headerOverflow; }
public void setHeaderOverflow(String _v) { _dirty = true; headerOverflow = _v; }
public List<Integer> headerData() { return headerData; }
public void setHeaderData(List<Integer> _v) { _dirty = true; headerData = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}
private Header header;
private List<ImageSegment> imageSegments;
private List<GraphicsSegment> graphicsSegments;
private List<TextSegment> textSegments;
private List<DataExtensionSegment> dataExtensionSegments;
private List<ReservedExtensionSegment> reservedExtensionSegments;
private Nitf _root;
private KaitaiStruct.ReadWrite _parent;
public Header header() { return header; }
public void setHeader(Header _v) { _dirty = true; header = _v; }
public List<ImageSegment> imageSegments() { return imageSegments; }
public void setImageSegments(List<ImageSegment> _v) { _dirty = true; imageSegments = _v; }
public List<GraphicsSegment> graphicsSegments() { return graphicsSegments; }
public void setGraphicsSegments(List<GraphicsSegment> _v) { _dirty = true; graphicsSegments = _v; }
public List<TextSegment> textSegments() { return textSegments; }
public void setTextSegments(List<TextSegment> _v) { _dirty = true; textSegments = _v; }
public List<DataExtensionSegment> dataExtensionSegments() { return dataExtensionSegments; }
public void setDataExtensionSegments(List<DataExtensionSegment> _v) { _dirty = true; dataExtensionSegments = _v; }
public List<ReservedExtensionSegment> reservedExtensionSegments() { return reservedExtensionSegments; }
public void setReservedExtensionSegments(List<ReservedExtensionSegment> _v) { _dirty = true; reservedExtensionSegments = _v; }
public Nitf _root() { return _root; }
public void set_root(Nitf _v) { _dirty = true; _root = _v; }
public KaitaiStruct.ReadWrite _parent() { return _parent; }
public void set_parent(KaitaiStruct.ReadWrite _v) { _dirty = true; _parent = _v; }
}