ndtkit-api 0.0.1__tar.gz

ndtkit_api-0.0.1/LICENSE

@@ -0,0 +1,42 @@
+Copyright (c) 2025 TESTIA SAS. All Rights Reserved.
+
+==============================================================================
+PROPRIETARY SOFTWARE LICENSE
+for the ndtkit_api
+==============================================================================
+
+This Application Programming Interface, including its documentation, data structures, and all related materials (collectively, the "API"), is proprietary software and the confidential intellectual property of TESTIA SAS ("Licensor").
+
+**1. LICENSE REQUIREMENT**
+
+Access to, and use of, this API is strictly conditional upon and requires that you (or the legal entity you represent) hold a valid, active, and fully paid commercial software license for the "NDTkit" software (the "NDTkit License").
+
+Any access or use of this API without a valid NDTkit License is unauthorized, constitutes a material breach of this agreement, and is a violation of Licensor's intellectual property rights.
+
+**2. GOVERNING AGREEMENT**
+
+Your use of this API is governed by the terms and conditions of your NDTkit License agreement, or a separate API Terms of Service provided by Licensor, whichever is applicable (the "Governing Agreement"). By accessing or using this API, you represent and warrant that you hold a valid NDTkit License and you agree to be bound by the terms of the Governing Agreement.
+
+**3. TERMINATION OF RIGHTS**
+
+Your right to use this API will terminate immediately and automatically, without notice, if your NDTkit License expires, is terminated, or is otherwise no longer valid. Upon such termination, you must cease all use of the API and destroy any related materials in your possession.
+
+**4. RESTRICTIONS**
+
+You may not, without express written permission from Licensor:
+a) Sublicense, sell, rent, lease, or otherwise distribute the API to any third party.
+b) Reverse engineer, decompile, disassemble, or attempt to derive the source code of the API.
+c) Use the API to create a product or service that competes with the NDTkit software or the API itself.
+d) Use the API for any purpose not expressly permitted by your Governing Agreement.
+
+**5. NO OTHER RIGHTS GRANTED**
+
+This license file does not grant you any rights to use, copy, modify, or distribute the API. All rights not expressly granted herein are reserved by TESTIA SAS.
+
+**6. DISCLAIMER OF WARRANTY**
+
+THE API IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+
+**7. LIMITATION OF LIABILITY**
+
+IN NO EVENT SHALL TESTIA SAS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE API OR THE USE OR OTHER DEALINGS IN THE API.

ndtkit_api-0.0.1/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: ndtkit_api
+Version: 0.0.1
+Summary: This Python API provides a high-level interface to interact with the NDTkit desktop application. It allows developers to script and automate NDTkit features remotely, leveraging the full power of the underlying Java application through a simple and pythonic library.
+Author-email: Cédric BERTRAND <cedric.bertrand@testia.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: py4j
+Dynamic: license-file
+
+# NDTkit Python API
+
+![Python API for NDTkit](https://img.shields.io/badge/API-Python-blue.svg)
+![Version](https://img.shields.io/badge/Version-1.0.0-orange.svg)
+![License](https://img.shields.io/badge/License-MIT-green.svg)
+
+This Python API provides a high-level interface to interact with the NDTkit desktop application. It allows developers to script and automate NDTkit features remotely, leveraging the full power of the underlying Java application through a simple and pythonic library.
+
+## How it Works ⚙️
+
+The API acts as a client that communicates with a dedicated socket server running within the NDTkit Java application.
+
+1.  **Python Call**: A function is called in Python (e.g., `NDTKitCScanInterface.open_cscan(...)`).
+2.  **JSON Serialization**: The call (class name, method name, parameters) is serialized into a JSON object.
+3.  **Socket Communication**: The JSON payload is sent over a TCP socket to the Java server.
+4.  **Java Execution**: The server deserializes the request, invokes the corresponding Java API method using reflection, and waits for the result.
+5.  **Return Value**: The result from the Java method is serialized back to JSON and sent to the Python client, which deserializes it into a Python object (like a `NICartographyFrameCScan` instance).
+
+## Prerequisites
+
+Before using this API, you must have:
+
+1.  **Python 3.9+** installed.
+2.  The **NDTkit desktop application** installed.
+3.  The Java socket server for the API must be running. The Python API can automatically launch it if configured correctly.
+
+## 🚀 Installation & Configuration
+
+1.  **Clone the repository** (or add it to your project). This library is not on PyPI.
+
+2.  **Configure the connection**: At the root of the `apipython` package, you will find a `config` directory. You need to edit the `config.ini` file.
+
+    ```ini
+    [Parameters]
+    SERVER_HOST = 127.0.0.1
+    SERVER_PORT = 32146
+    MESSAGE_TYPE = 10
+
+    # IMPORTANT: Update this path to point to your serverMode script
+    SOCKET_SERVER_COMMAND = <NDTKIT_INSTALL_FOLDER>/NDTkit.vbs # Alternative: <NDTKIT_INSTALL_FOLDER>/modules/serverMode/serverMode.bat
+
+    SERVER_CONNECTION_TIMEOUT = 120
+    ```
+
+    - **`SERVER_HOST`**: The IP address of the machine running NDTkit. Use `127.0.0.1` if it's on the same machine.
+    - **`SERVER_PORT`**: The port for the socket communication. This must match the port the NDTkit server is listening on.
+    - **`SOCKET_SERVER_COMMAND`**: **This is the most critical setting.** It's the command used to launch the Java socket server. The Python API will execute this command if it cannot connect to the server.
+
+## Usage Example
+
+Here is a simple example showing how to open a C-Scan, modify a pixel, and save it to a new file.
+
+```python
+# examples.py
+
+import NDTKitCScanInterface
+from model.frame.NICartographyFrameCScan import NICartographyFrameCScan
+
+def change_pixel_value(input_file: str, output_file: str):
+    """
+    Opens a C-Scan, modifies the value of the first pixel, saves it,
+    and re-opens it for display.
+    """
+    print(f"Opening C-Scan: {input_file}")
+    # The server is launched automatically if not running
+    cscan = NDTKitCScanInterface.openCScan(input_file)
+
+    if not cscan:
+        print("Failed to open C-Scan.")
+        return
+
+    print(f"C-Scan opened successfully with UUID: {cscan.get_uuid()}")
+
+    print("Retrieving data matrix...")
+    data = cscan.get_data()
+    print(f"Original value at [0][0]: {data[0][0]}")
+
+    # Modify the data
+    data[0][0] = 12.0
+    print(f"Setting new value at [0][0] to 12.0")
+    cscan.set_data(data)
+
+    print(f"Saving modified C-Scan to: {output_file}")
+    NDTKitCScanInterface.saveCscan(cscan, output_file)
+
+    print("Re-opening the saved C-Scan to verify.")
+    NDTKitCScanInterface.openCScan(output_file, displayResult=True)
+    print("Done.")
+
+
+if __name__ == "__main__":
+    # Make sure to use paths that are valid on your system
+    input_cscan_path = "D:/Data/NKC/dd_carto.nkc"
+    output_cscan_path = "D:/tmp/modified_cscan.nkc"
+    change_pixel_value(input_cscan_path, output_cscan_path)
+```
+
+## A class/method available in the Java API which is not appearing in this Python API
+
+It can reachable anyway, it's just the auto-completion of your IDE that is not working. Actually this Python API is using [py4j](https://www.py4j.org/) that allows to access any Java API function.
+Here's an example on how to access to `agi.ndtkit.api.NDTKitCScanInterface.openCScan(String)` without using this wrapper project:
+
+```python
+from ndtkit_socket_connection import gateway
+
+
+gateway.jvm.agi.ndtkit.api.NDTKitCScanInterface.openCScan("path/to/my/cscan")
+
+```
+
+So please refers to the NDTkit Javadoc to have an exhaustive look at all the available actions and call them using this solution if they are not available directly in this Python API.

ndtkit_api-0.0.1/README.md

@@ -0,0 +1,111 @@
+# NDTkit Python API
+
+![Python API for NDTkit](https://img.shields.io/badge/API-Python-blue.svg)
+![Version](https://img.shields.io/badge/Version-1.0.0-orange.svg)
+![License](https://img.shields.io/badge/License-MIT-green.svg)
+
+This Python API provides a high-level interface to interact with the NDTkit desktop application. It allows developers to script and automate NDTkit features remotely, leveraging the full power of the underlying Java application through a simple and pythonic library.
+
+## How it Works ⚙️
+
+The API acts as a client that communicates with a dedicated socket server running within the NDTkit Java application.
+
+1.  **Python Call**: A function is called in Python (e.g., `NDTKitCScanInterface.open_cscan(...)`).
+2.  **JSON Serialization**: The call (class name, method name, parameters) is serialized into a JSON object.
+3.  **Socket Communication**: The JSON payload is sent over a TCP socket to the Java server.
+4.  **Java Execution**: The server deserializes the request, invokes the corresponding Java API method using reflection, and waits for the result.
+5.  **Return Value**: The result from the Java method is serialized back to JSON and sent to the Python client, which deserializes it into a Python object (like a `NICartographyFrameCScan` instance).
+
+## Prerequisites
+
+Before using this API, you must have:
+
+1.  **Python 3.9+** installed.
+2.  The **NDTkit desktop application** installed.
+3.  The Java socket server for the API must be running. The Python API can automatically launch it if configured correctly.
+
+## 🚀 Installation & Configuration
+
+1.  **Clone the repository** (or add it to your project). This library is not on PyPI.
+
+2.  **Configure the connection**: At the root of the `apipython` package, you will find a `config` directory. You need to edit the `config.ini` file.
+
+    ```ini
+    [Parameters]
+    SERVER_HOST = 127.0.0.1
+    SERVER_PORT = 32146
+    MESSAGE_TYPE = 10
+
+    # IMPORTANT: Update this path to point to your serverMode script
+    SOCKET_SERVER_COMMAND = <NDTKIT_INSTALL_FOLDER>/NDTkit.vbs # Alternative: <NDTKIT_INSTALL_FOLDER>/modules/serverMode/serverMode.bat
+
+    SERVER_CONNECTION_TIMEOUT = 120
+    ```
+
+    - **`SERVER_HOST`**: The IP address of the machine running NDTkit. Use `127.0.0.1` if it's on the same machine.
+    - **`SERVER_PORT`**: The port for the socket communication. This must match the port the NDTkit server is listening on.
+    - **`SOCKET_SERVER_COMMAND`**: **This is the most critical setting.** It's the command used to launch the Java socket server. The Python API will execute this command if it cannot connect to the server.
+
+## Usage Example
+
+Here is a simple example showing how to open a C-Scan, modify a pixel, and save it to a new file.
+
+```python
+# examples.py
+
+import NDTKitCScanInterface
+from model.frame.NICartographyFrameCScan import NICartographyFrameCScan
+
+def change_pixel_value(input_file: str, output_file: str):
+    """
+    Opens a C-Scan, modifies the value of the first pixel, saves it,
+    and re-opens it for display.
+    """
+    print(f"Opening C-Scan: {input_file}")
+    # The server is launched automatically if not running
+    cscan = NDTKitCScanInterface.openCScan(input_file)
+
+    if not cscan:
+        print("Failed to open C-Scan.")
+        return
+
+    print(f"C-Scan opened successfully with UUID: {cscan.get_uuid()}")
+
+    print("Retrieving data matrix...")
+    data = cscan.get_data()
+    print(f"Original value at [0][0]: {data[0][0]}")
+
+    # Modify the data
+    data[0][0] = 12.0
+    print(f"Setting new value at [0][0] to 12.0")
+    cscan.set_data(data)
+
+    print(f"Saving modified C-Scan to: {output_file}")
+    NDTKitCScanInterface.saveCscan(cscan, output_file)
+
+    print("Re-opening the saved C-Scan to verify.")
+    NDTKitCScanInterface.openCScan(output_file, displayResult=True)
+    print("Done.")
+
+
+if __name__ == "__main__":
+    # Make sure to use paths that are valid on your system
+    input_cscan_path = "D:/Data/NKC/dd_carto.nkc"
+    output_cscan_path = "D:/tmp/modified_cscan.nkc"
+    change_pixel_value(input_cscan_path, output_cscan_path)
+```
+
+## A class/method available in the Java API which is not appearing in this Python API
+
+It can reachable anyway, it's just the auto-completion of your IDE that is not working. Actually this Python API is using [py4j](https://www.py4j.org/) that allows to access any Java API function.
+Here's an example on how to access to `agi.ndtkit.api.NDTKitCScanInterface.openCScan(String)` without using this wrapper project:
+
+```python
+from ndtkit_socket_connection import gateway
+
+
+gateway.jvm.agi.ndtkit.api.NDTKitCScanInterface.openCScan("path/to/my/cscan")
+
+```
+
+So please refers to the NDTkit Javadoc to have an exhaustive look at all the available actions and call them using this solution if they are not available directly in this Python API.

ndtkit_api-0.0.1/ndtkit_api/NDTKitAScanInterface.py

@@ -0,0 +1,6 @@
+from .ndtkit_socket_connection import gateway
+from .model.frame.NICartographyFrameAScan import NICartographyFrameAScan
+
+
+def openAScan(ascanFilePath: str, scanId: int = -1, displayResult: bool = True) -> NICartographyFrameAScan:
+    return NICartographyFrameAScan(gateway.jvm.agi.ndtkit.api.NDTKitAScanInterface.openAScan(ascanFilePath, scanId, displayResult))

ndtkit_api-0.0.1/ndtkit_api/NDTKitCScanInterface.py

@@ -0,0 +1,32 @@
+from .ndtkit_socket_connection import gateway, call_api_method
+from .model.frame.NICartographyFrameCScan import NICartographyFrameCScan
+
+
+def openCScan(cscanFilePath: str, displayResult: bool = True) -> NICartographyFrameCScan:
+    return NICartographyFrameCScan(gateway.jvm.agi.ndtkit.api.NDTKitCScanInterface.openCScan(cscanFilePath, displayResult)[0])
+
+
+def saveCscan(cscan: NICartographyFrameCScan, filepath: str):
+    return gateway.jvm.agi.ndtkit.api.NDTKitCScanInterface.saveCscan(cscan._java_object, filepath)
+
+
+def createCscan(data: list[list[float]], acquisition_name: str, x_res: float, y_res: float) -> NICartographyFrameCScan:
+    parameters = [
+        {
+            "type": "float[][]",
+            "value": str(data)
+        },
+        {
+            "type": "java.lang.String",
+            "value": acquisition_name
+        },
+        {
+            "type": "float",
+            "value": x_res
+        },
+        {
+            "type": "float",
+            "value": y_res
+        }
+    ]
+    return call_api_method("agi.ndtkit.api", "NDTKitCScanInterface", "createCscan", parameters)

ndtkit_api-0.0.1/ndtkit_api/config/__init__.py

@@ -0,0 +1,14 @@
+import configparser
+from pathlib import Path
+
+config = configparser.ConfigParser()
+
+config.read(Path(__file__).parent / 'config.ini')
+
+SERVER_HOST = config.get('Parameters', 'SERVER_HOST', fallback="127.0.0.1")
+SERVER_PORT = config.getint('Parameters', 'SERVER_PORT', fallback=32146)
+MESSAGE_TYPE = config.getint('Parameters', 'MESSAGE_TYPE', fallback=10)
+
+# Command to launch NDTkit's socket server.
+SOCKET_SERVER_COMMAND = config.get('Parameters', 'SOCKET_SERVER_COMMAND', fallback="C:/Program Files/NDTkit/modules/serverMode/serverMode.vbs")
+SERVER_CONNECTION_TIMEOUT = config.getint('Parameters', 'SERVER_CONNECTION_TIMEOUT', fallback=120)

ndtkit_api-0.0.1/ndtkit_api/model/ascan/NIAScanGate.py

@@ -0,0 +1,11 @@
+from py4j.java_gateway import JavaObject
+
+
+class NIAScanGate:
+    """Base class for NIAScanGate, generated from Java API."""
+
+    def __init__(self, java_object: JavaObject):
+        self._java_object = java_object
+
+    def set_velocity(self, us_velocity: float) -> None:
+        return self._java_object.setVelocity(us_velocity)

ndtkit_api-0.0.1/ndtkit_api/model/frame/NICartographyFrame.py

@@ -0,0 +1,48 @@
+from py4j.java_gateway import JavaObject
+
+
+class NICartographyFrame:
+    def __init__(self, java_object: JavaObject):
+        self._java_object = java_object
+
+    def minimize_frame(self, is_minimum: bool):
+        return self._java_object.minimizeFrame(is_minimum)
+
+    def set_title(self, title: str):
+        return self._java_object.setTitle(title)
+
+    def get_scan_type(self):
+        return self._java_object.getScanType()
+
+    def maximize_frame(self, is_maximum: bool):
+        return self._java_object.maximizeFrame(is_maximum)
+
+    def get_projection_cuboid(self):
+        return self._java_object.getProjectionCuboid()
+
+    def get_size(self):
+        return self._java_object.getSize()
+
+    def get_title(self):
+        return self._java_object.getTitle()
+
+    def json_of_scan_reader_parameter(self):
+        return self._java_object.jsonOfScanReaderParameter()
+
+    def get_uuid(self):
+        return str(self._java_object.getUUID())
+
+    def get_file_path(self):
+        return self._java_object.getFilePath()
+
+    def set_file_path(self, filepath: str):
+        return self._java_object.setFilePath(filepath)
+
+    def change_size(self, width: int, height: int):
+        return self._java_object.changeSize(width, height)
+
+    def close(self):
+        return self._java_object.close()
+
+    def get_ifi(self):
+        return self._java_object.getIfi()

ndtkit_api-0.0.1/ndtkit_api/model/frame/NICartographyFrameAScan.py

@@ -0,0 +1,91 @@
+from .NICartographyFrame import NICartographyFrame
+from ...model.scans.ascan.NIAScan import NIAScan
+from py4j.java_gateway import JavaObject
+from typing import Any, List
+
+
+class NICartographyFrameAScan(NICartographyFrame):
+    """Base class for NICartographyFrameAScan, generated from Java API."""
+
+    def __init__(self, java_object: JavaObject):
+        super().__init__(java_object)
+        self._java_object = java_object
+
+    def get_file_path(self) -> str:
+        return self._java_object.getFilePath()
+
+    def get_raw_data_values(self, row: int, column: int) -> NIAScan:
+        return self._java_object.getRawDataValues(row, column)
+
+    def get_raw_data_values_no_factor(self, row: int, column: int) -> NIAScan:
+        return self._java_object.getRawDataValuesNoFactor(row, column)
+
+    def get_ascan_length(self) -> int:
+        return self._java_object.getAscanLength()
+
+    def get_row(self, row_index: int) -> list[NIAScan]:
+        row_of_ascans = self._java_object.getRow(row_index)
+        return [NIAScan(ascan) for ascan in row_of_ascans]
+
+    def get_column(self, row_column: int) -> List[Any]:
+        return self._java_object.getColumn(row_column)
+
+    def get_data_values(self, row: int, column: int) -> NIAScan:
+        return self._java_object.getDataValues(row, column)
+
+    def get_row_number(self) -> int:
+        return self._java_object.getRowNumber()
+
+    def get_column_number(self) -> int:
+        return self._java_object.getColumnNumber()
+
+    def set_file_path(self, filepath: str) -> None:
+        return self._java_object.setFilePath(filepath)
+
+    def get_x_resolution(self) -> float:
+        return self._java_object.getXResolution()
+
+    def get_y_resolution(self) -> float:
+        return self._java_object.getYResolution()
+
+    def get_num_rate(self) -> float:
+        return self._java_object.getNumRate()
+
+    def set_full_range_bscan(self) -> None:
+        return self._java_object.setFullRangeBScan()
+
+    def get_ascan_gates(self):
+        return self._java_object.getAScanGates()
+
+    def get_bscan_gate(self):
+        return self._java_object.getBScanGate()
+
+    def get_velocity_from_file(self) -> float:
+        return self._java_object.getVelocityFromFile()
+
+    def get_bscan_vertical_resolution(self) -> float:
+        return self._java_object.getBScanVerticalResolution()
+
+    def get_bscan_data(self, bscan_position: int) -> List[List[float]]:
+        return self._java_object.getBScanData(bscan_position)
+
+    def get_dscan_data(self, dscan_position: int) -> List[List[float]]:
+        return self._java_object.getDScanData(dscan_position)
+
+    def get_acquisition_type(self):
+        return self._java_object.getAcquisitionType()
+
+    def set_x_origin_position(self, x_offset: float) -> None:
+        return self._java_object.setXOriginPosition(x_offset)
+
+    def set_y_origin_position(self, y_offset: float) -> None:
+        return self._java_object.setYOriginPosition(y_offset)
+
+    def get_x_origin_position(self) -> float:
+        return self._java_object.getXOriginPosition()
+
+    def get_y_origin_position(self) -> float:
+        return self._java_object.getYOriginPosition()
+
+    def get_current_ascan(self) -> NIAScan:
+        return self._java_object.getCurrentAscan()

ndtkit_api-0.0.1/ndtkit_api/model/frame/NICartographyFrameCScan.py

@@ -0,0 +1,202 @@
+from typing import Any, List
+from ...ndtkit_socket_connection import call_api_method
+from .NICartographyFrame import NICartographyFrame
+
+
+class NICartographyFrameCScan(NICartographyFrame):
+
+    def get_identifier(self) -> int:
+        return self._java_object.getIdentifier()
+
+    def set_identifier(self, id: int) -> None:
+        return self._java_object.setIdentifier(id)
+
+    def get_x_resolution(self) -> float:
+        return self._java_object.getXResolution()
+
+    def get_y_resolution(self) -> float:
+        return self._java_object.getYResolution()
+
+    def get_resolution(self):
+        return self._java_object.getResolution()
+
+    def get_x_origin(self) -> float:
+        return self._java_object.getXOrigin()
+
+    def get_intrinsic_x_origin(self) -> float:
+        return self._java_object.getIntrinsicXOrigin()
+
+    def get_y_origin(self) -> float:
+        return self._java_object.getYOrigin()
+
+    def get_intrinsic_y_origin(self) -> float:
+        return self._java_object.getIntrinsicYOrigin()
+
+    def get_flat_data(self):
+        return self._java_object.getFlatData()
+
+    def get_data_bound(self, roi) -> List[List[float]]:
+        return self._java_object.getDataBound(roi)
+
+    def get_flat_data(self, roi) -> List[Any]:
+        return self._java_object.getFlatData(roi)
+
+    def add_processing_into_historic_list(self, text: str) -> None:
+        return self._java_object.addProcessingIntoHistoricList(text)
+
+    def get_file_path(self) -> str:
+        return self._java_object.getFilePath()
+
+    def set_automation_identifier(self, report_identifier: str) -> None:
+        return self._java_object.setAutomationIdentifier(report_identifier)
+
+    def get_automation_identifier(self) -> str:
+        return self._java_object.getAutomationIdentifier()
+
+    def get_unit(self):
+        return self._java_object.getUnit()
+
+    def get_palette(self):
+        return self._java_object.getPalette()
+
+    def load_palette(self, palette_pathname: str) -> None:
+        return self._java_object.loadPalette(palette_pathname)
+
+    def get_defects_detection(self):
+        return self._java_object.getDefectsDetection()
+
+    def zoom(self, x: float, y: float, width: float, height: float, ignore_ratio: bool) -> None:
+        return self._java_object.zoom(x, y, width, height, ignore_ratio)
+
+    def zoom(self, x: float, y: float, width: float, height: float) -> None:
+        return self._java_object.zoom(x, y, width, height)
+
+    def rotate(self, angle: int) -> None:
+        return self._java_object.rotate(angle)
+
+    def get_type(self):
+        return self._java_object.getType()
+
+    def horizontal_symmetry(self) -> None:
+        return self._java_object.horizontalSymmetry()
+
+    def vertical_symmetry(self) -> None:
+        return self._java_object.verticalSymmetry()
+
+    def get_amplitude_reference(self) -> float:
+        return self._java_object.getAmplitudeReference()
+
+    def get_velocity(self) -> float:
+        return self._java_object.getVelocity()
+
+    def get_ply_thickness(self) -> float:
+        return self._java_object.getPlyThickness()
+
+    def get_screenshot(self, representation_type, display_palette: bool, display_roi_layer: bool, display_mask_layer: bool, display_defect_layer: bool, display_dressing_layer: bool, display_rulers: bool, display_at_real_size: bool):
+        return self._java_object.getScreenshot(representation_type, display_palette, display_roi_layer, display_mask_layer, display_defect_layer, display_dressing_layer, display_rulers, display_at_real_size)
+
+    def set_file_path(self, filepath: str) -> None:
+        return self._java_object.setFilePath(filepath)
+
+    def set_unit_without_conversion(self, unit) -> None:
+        return self._java_object.setUnitWithoutConversion(unit)
+
+    def set_resolution_unit(self, unit) -> None:
+        return self._java_object.setResolutionUnit(unit)
+
+    def set_y_origin_position(self, position_in_mm: float) -> None:
+        return self._java_object.setYOriginPosition(position_in_mm)
+
+    def set_x_origin_position(self, position_in_mm: float) -> None:
+        return self._java_object.setXOriginPosition(position_in_mm)
+
+    def get_comment(self) -> str:
+        return self._java_object.getComment()
+
+    def set_comment(self, comment: str) -> None:
+        return self._java_object.setComment(comment)
+
+    def get_min_value(self) -> float:
+        return self._java_object.getMinValue()
+
+    def get_max_value(self) -> float:
+        return self._java_object.getMaxValue()
+
+    def get_metadata(self, metadata_id: str) -> Any:
+        return self._java_object.getMetadata(metadata_id)
+
+    def set_metadata(self, metadata_id: str, metadata: Any) -> None:
+        return self._java_object.setMetadata(metadata_id, metadata)
+
+    def apply_zoom(self, zoom_fit) -> None:
+        return self._java_object.applyZoom(zoom_fit)
+
+    def get_event_manager(self):
+        return self._java_object.getEventManager()
+
+    def is_still_displayed(self) -> bool:
+        return self._java_object.isStillDisplayed()
+
+    def request_focus(self) -> None:
+        return self._java_object.requestFocus()
+
+    def get_zoom_factor_x(self) -> float:
+        return self._java_object.getZoomFactorX()
+
+    def get_zoom_factor_y(self) -> float:
+        return self._java_object.getZoomFactorY()
+
+    def get_dynamic_layer_manager(self):
+        return self._java_object.getDynamicLayerManager()
+
+    def refresh_layers(self) -> None:
+        return self._java_object.refreshLayers()
+
+    def duplicate(self):
+        return self._java_object.duplicate()
+
+    def json_of_scan_reader_parameter(self) -> str:
+        return self._java_object.jsonOfScanReaderParameter()
+
+    def set_auto_update_data(self, auto_update_data: bool) -> None:
+        return self._java_object.setAutoUpdateData(auto_update_data)
+
+    def update_data(self, update_palette: bool) -> None:
+        return self._java_object.updateData(update_palette)
+
+    def get_projection_cuboid(self):
+        return self._java_object.getProjectionCuboid()
+
+    def get_position3d(self, real_x: float, real_y: float):
+        return self._java_object.getPosition3d(real_x, real_y)
+
+    def get_horizontal_echodynamic_curve(self):
+        return self._java_object.getHorizontalEchodynamicCurve()
+
+    def get_vertical_echodynamic_curve(self):
+        return self._java_object.getVerticalEchodynamicCurve()
+
+    def get_data(self, roi=None) -> list[list[float]]:
+        if (roi):
+            return self._java_object.get_data(roi)
+
+        parameters = [
+            {
+                "type": "agi.ndtkit.api.model.frame.NICartographyFrameCScan",
+                "value": self.get_uuid(),
+            }
+        ]
+        return call_api_method("agi.ndtkit.api.model.frame", "NICartographyFrameCScan", "getData", parameters)
+
+    def set_data(self, data: list[list[float]]):
+        parameters = [
+            {
+                "type": "agi.ndtkit.api.model.frame.NICartographyFrameCScan",
+                "value": self.get_uuid(),
+            },
+            {
+                "type": "float[][]",
+                "value": str(data)
+            }
+        ]
+        call_api_method("agi.ndtkit.api.model.frame", "NICartographyFrameCScan", "setData", parameters)

ndtkit_api-0.0.1/ndtkit_api/model/scans/ascan/NIAScan.py

@@ -0,0 +1,29 @@
+from py4j.java_gateway import JavaObject
+
+
+class NIAScan:
+    """Base class for NIAScan, generated from Java API."""
+
+    def __init__(self, java_object: JavaObject, json_model=None):
+        self._java_object = java_object
+        self.json_model = json_model
+
+    def get_all_tof_values_from_this_ascan_and_sub_ascans(self) -> list[float]:
+        return self._java_object.getAllTofValuesFromThisAScanAndSubAscans()
+
+    def get_all_amp_values_from_this_ascan_and_sub_ascans(self) -> list[float]:
+        return self._java_object.getAllAmpValuesFromThisAScanAndSubAscans()
+
+    def get_amp_values(self) -> list[float]:
+        if self.json_model and "amp" in self.json_model:
+            return self.json_model["amp"]
+        return self._java_object.getAmpValues()
+
+    def get_tof_values(self) -> list[float]:
+        return self._java_object.getTofValues()
+
+    def get_sub_ascans(self):
+        return self._java_object.getSubAscans()
+
+    def get_column(self) -> int:
+        return self._java_object.getColumn()

ndtkit_api-0.0.1/ndtkit_api/ndtkit_socket_connection.py

@@ -0,0 +1,121 @@
+import socket
+import struct  # Required to pack numbers into bytes
+import json   # Required to work with JSON data
+from .config import SERVER_HOST, SERVER_PORT, MESSAGE_TYPE, SOCKET_SERVER_COMMAND, SERVER_CONNECTION_TIMEOUT
+from py4j.java_gateway import JavaGateway
+import time
+import subprocess
+
+gateway = JavaGateway()
+
+
+def check_server() -> socket.socket | None:
+    """
+    Creates a socket and tries to connect to the server.
+    Returns the connected socket object on success, or None on failure.
+    """
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.settimeout(2)  # Set a connection timeout of 2 seconds
+        # 2. Attempt to connect
+        s.connect((SERVER_HOST, SERVER_PORT))
+        # 3. Return the valid, open socket
+        return s
+    except (ConnectionRefusedError, socket.timeout):
+        # The connection failed, close the created socket and return None
+        s.close()
+        return None
+
+
+def send_custom_protocol_message(json_data):
+    """
+    Builds and sends a message according to the custom Netty protocol.
+    Format: [4-byte length][1-byte type][json payload]
+    """
+    try:
+        # 1. Convert the Python dictionary to a JSON string, then encode it into bytes.
+        #    Using ensure_ascii=False is good practice for non-latin characters.
+        json_payload_bytes = json.dumps(json_data, ensure_ascii=False).encode('utf-8')
+
+        # 2. Calculate the "messageLength" for the header.
+        #    This is the length of the type (1 byte) + the length of the JSON payload.
+        header_length = 1 + len(json_payload_bytes)
+
+        # 3. Pack the header fields into bytes.
+        #    '>' = Big-Endian (Network Byte Order, standard for Java)
+        #    'I' = Unsigned Integer (4 bytes)
+        #    'B' = Unsigned Char (1 byte)
+        length_prefix = struct.pack('>I', header_length)
+        type_prefix = struct.pack('>B', MESSAGE_TYPE)
+
+        # 4. Assemble the final message by concatenating all parts in the correct order.
+        payload_to_send = length_prefix + type_prefix + json_payload_bytes
+
+        # 5. Connect and send the message.
+        start_time = time.time()
+        # Loop until the timeout is reached
+        is_ndtkit_launch_command_sent = False
+        while time.time() - start_time < SERVER_CONNECTION_TIMEOUT:
+            client_socket = check_server()
+            if client_socket:
+                break  # Exit the loop since the server was found
+            else:
+                if not is_ndtkit_launch_command_sent:
+                    is_ndtkit_launch_command_sent = True
+                    if SOCKET_SERVER_COMMAND.endswith(".bat"):
+                        subprocess.Popen(SOCKET_SERVER_COMMAND)
+                    else:
+                        subprocess.call(SOCKET_SERVER_COMMAND)
+                time.sleep(5)
+
+        if not client_socket:
+            raise ConnectionError("Impossible to reach the socket server")
+
+        client_socket.settimeout(None)  # Remove the timeout
+        client_socket.sendall(payload_to_send)
+
+        # --- Receive the response ---
+
+        # 1. Read the 4-byte total length prefix
+        response_len_bytes = client_socket.recv(4)
+        if not response_len_bytes:
+            print("<-- Server closed connection without response.")
+            return None
+
+        total_len = struct.unpack('>I', response_len_bytes)[0]
+
+        # 2. Read the 1-byte message type
+        response_type_byte = client_socket.recv(1)
+        if not response_type_byte:
+            raise ConnectionError("Connection broken after reading length.")
+
+        # 3. Calculate the length of the JSON payload
+        json_len = total_len - 1
+
+        # 4. Read the JSON payload
+        response_payload = b''
+        if json_len > 0:
+            while len(response_payload) < json_len:
+                chunk = client_socket.recv(json_len - len(response_payload))
+                if not chunk:
+                    raise ConnectionError("Socket connection broken before full response was received.")
+                response_payload += chunk
+
+        # 5. Decode and parse the JSON
+        return json.loads(response_payload.decode('utf-8'))
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+    finally:
+        if client_socket:
+            client_socket.close()
+
+
+def call_api_method(package_name, class_name, method_name, parameters):
+    json_command = {
+        "packageName": package_name,
+        "className": class_name,
+        "methodName": method_name,
+        "parameters": parameters
+    }
+    return send_custom_protocol_message(json_command)

ndtkit_api-0.0.1/ndtkit_api.egg-info/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: ndtkit_api
+Version: 0.0.1
+Summary: This Python API provides a high-level interface to interact with the NDTkit desktop application. It allows developers to script and automate NDTkit features remotely, leveraging the full power of the underlying Java application through a simple and pythonic library.
+Author-email: Cédric BERTRAND <cedric.bertrand@testia.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: py4j
+Dynamic: license-file
+
+# NDTkit Python API
+
+![Python API for NDTkit](https://img.shields.io/badge/API-Python-blue.svg)
+![Version](https://img.shields.io/badge/Version-1.0.0-orange.svg)
+![License](https://img.shields.io/badge/License-MIT-green.svg)
+
+This Python API provides a high-level interface to interact with the NDTkit desktop application. It allows developers to script and automate NDTkit features remotely, leveraging the full power of the underlying Java application through a simple and pythonic library.
+
+## How it Works ⚙️
+
+The API acts as a client that communicates with a dedicated socket server running within the NDTkit Java application.
+
+1.  **Python Call**: A function is called in Python (e.g., `NDTKitCScanInterface.open_cscan(...)`).
+2.  **JSON Serialization**: The call (class name, method name, parameters) is serialized into a JSON object.
+3.  **Socket Communication**: The JSON payload is sent over a TCP socket to the Java server.
+4.  **Java Execution**: The server deserializes the request, invokes the corresponding Java API method using reflection, and waits for the result.
+5.  **Return Value**: The result from the Java method is serialized back to JSON and sent to the Python client, which deserializes it into a Python object (like a `NICartographyFrameCScan` instance).
+
+## Prerequisites
+
+Before using this API, you must have:
+
+1.  **Python 3.9+** installed.
+2.  The **NDTkit desktop application** installed.
+3.  The Java socket server for the API must be running. The Python API can automatically launch it if configured correctly.
+
+## 🚀 Installation & Configuration
+
+1.  **Clone the repository** (or add it to your project). This library is not on PyPI.
+
+2.  **Configure the connection**: At the root of the `apipython` package, you will find a `config` directory. You need to edit the `config.ini` file.
+
+    ```ini
+    [Parameters]
+    SERVER_HOST = 127.0.0.1
+    SERVER_PORT = 32146
+    MESSAGE_TYPE = 10
+
+    # IMPORTANT: Update this path to point to your serverMode script
+    SOCKET_SERVER_COMMAND = <NDTKIT_INSTALL_FOLDER>/NDTkit.vbs # Alternative: <NDTKIT_INSTALL_FOLDER>/modules/serverMode/serverMode.bat
+
+    SERVER_CONNECTION_TIMEOUT = 120
+    ```
+
+    - **`SERVER_HOST`**: The IP address of the machine running NDTkit. Use `127.0.0.1` if it's on the same machine.
+    - **`SERVER_PORT`**: The port for the socket communication. This must match the port the NDTkit server is listening on.
+    - **`SOCKET_SERVER_COMMAND`**: **This is the most critical setting.** It's the command used to launch the Java socket server. The Python API will execute this command if it cannot connect to the server.
+
+## Usage Example
+
+Here is a simple example showing how to open a C-Scan, modify a pixel, and save it to a new file.
+
+```python
+# examples.py
+
+import NDTKitCScanInterface
+from model.frame.NICartographyFrameCScan import NICartographyFrameCScan
+
+def change_pixel_value(input_file: str, output_file: str):
+    """
+    Opens a C-Scan, modifies the value of the first pixel, saves it,
+    and re-opens it for display.
+    """
+    print(f"Opening C-Scan: {input_file}")
+    # The server is launched automatically if not running
+    cscan = NDTKitCScanInterface.openCScan(input_file)
+
+    if not cscan:
+        print("Failed to open C-Scan.")
+        return
+
+    print(f"C-Scan opened successfully with UUID: {cscan.get_uuid()}")
+
+    print("Retrieving data matrix...")
+    data = cscan.get_data()
+    print(f"Original value at [0][0]: {data[0][0]}")
+
+    # Modify the data
+    data[0][0] = 12.0
+    print(f"Setting new value at [0][0] to 12.0")
+    cscan.set_data(data)
+
+    print(f"Saving modified C-Scan to: {output_file}")
+    NDTKitCScanInterface.saveCscan(cscan, output_file)
+
+    print("Re-opening the saved C-Scan to verify.")
+    NDTKitCScanInterface.openCScan(output_file, displayResult=True)
+    print("Done.")
+
+
+if __name__ == "__main__":
+    # Make sure to use paths that are valid on your system
+    input_cscan_path = "D:/Data/NKC/dd_carto.nkc"
+    output_cscan_path = "D:/tmp/modified_cscan.nkc"
+    change_pixel_value(input_cscan_path, output_cscan_path)
+```
+
+## A class/method available in the Java API which is not appearing in this Python API
+
+It can reachable anyway, it's just the auto-completion of your IDE that is not working. Actually this Python API is using [py4j](https://www.py4j.org/) that allows to access any Java API function.
+Here's an example on how to access to `agi.ndtkit.api.NDTKitCScanInterface.openCScan(String)` without using this wrapper project:
+
+```python
+from ndtkit_socket_connection import gateway
+
+
+gateway.jvm.agi.ndtkit.api.NDTKitCScanInterface.openCScan("path/to/my/cscan")
+
+```
+
+So please refers to the NDTkit Javadoc to have an exhaustive look at all the available actions and call them using this solution if they are not available directly in this Python API.

ndtkit_api-0.0.1/ndtkit_api.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+ndtkit_api/NDTKitAScanInterface.py
+ndtkit_api/NDTKitCScanInterface.py
+ndtkit_api/ndtkit_socket_connection.py
+ndtkit_api.egg-info/PKG-INFO
+ndtkit_api.egg-info/SOURCES.txt
+ndtkit_api.egg-info/dependency_links.txt
+ndtkit_api.egg-info/requires.txt
+ndtkit_api.egg-info/top_level.txt
+ndtkit_api/config/__init__.py
+ndtkit_api/model/ascan/NIAScanGate.py
+ndtkit_api/model/frame/NICartographyFrame.py
+ndtkit_api/model/frame/NICartographyFrameAScan.py
+ndtkit_api/model/frame/NICartographyFrameCScan.py
+ndtkit_api/model/scans/ascan/NIAScan.py

ndtkit_api-0.0.1/ndtkit_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ndtkit_api-0.0.1/ndtkit_api.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests
+py4j

ndtkit_api-0.0.1/ndtkit_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+ndtkit_api

ndtkit_api-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ndtkit_api"
+version = "0.0.1"
+authors = [
+  { name="Cédric BERTRAND", email="cedric.bertrand@testia.com" },
+]
+description = "This Python API provides a high-level interface to interact with the NDTkit desktop application. It allows developers to script and automate NDTkit features remotely, leveraging the full power of the underlying Java application through a simple and pythonic library."
+readme = "README.md"
+requires-python = ">=3.11.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development",
+]
+dependencies = [
+    "requests",
+    "py4j"
+]

ndtkit_api-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+