Script

# Get the measurement object at input 0
measurement = get_measurement(0)

# Extract the value from the measurement
measurement_value = measurement.value

# Calculate a new measurement value
measurement_output = 2 * measurement_value

# Send the calculated value as a new measurement to output 0
send_measurement(0, measurement_output)

import csv 

# Get measurement objects
measurement_1 = get_measurement(0)
measurement_2 = get_measurement(1)

# Extract values from measurement objects
measurement_1_value = measurement_1.value
measurement_2_value = measurement_2.value

# Path to the output CSV file
output_path = r'C:\GoTools\Script\measurement.csv'
 
# Write measurements to CSV file
with open(output_path, 'a') as f:
    writer = csv.writer(f)
    writer.writerow([measurement_1_value, measurement_2_value])

# Import the math module to access mathematical functions
import math

# Get the measurement object at input 0
measurement = get_measurement(0)

# Extract the value from the measurement
measurement_value = measurement.value

# Calculate the square root of the absolute value using the Math module
sqrt_value = math.sqrt(math.fabs(measurement_value))

# Send the square root as a new measurement to output 0
send_measurement(0, sqrt_value)

# Check if any inputs are invalid
if any_input_invalid():
  send_all_invalid()

# Get the input measurement
measurement0 = get_measurement(0)

# Access validity from a measurement
if is_valid(measurement0):
  log_info("The input measurement is Valid")
else:
  log_info("The input measurement is Invalid")

# Access decision from a measurement
if measurement0.decision == MeasurementDecision.PASS:
  log_info("The input measurement has a Pass decision") 
else:
  log_info("The input measurement has a Failed decision")

profile = get_profile(0)

stamp = profile.header.stamp

log_info('Stamp = {}'.format(vars(stamp)))

send_measurement(0, stamp.frame)
send_measurement(1, stamp.time)
send_measurement(2, stamp.encoder)

# Get an array of measurement objects at input 0
measurements = get_measurement(0)

# Extract the values from each measurement object
measurement_values = []
for measurement in measurements:
    measurement_values.append(measurement.value)

# Calculate new values
measurements_output = [value * 2 for value in measurement_values]

# Send the calculated values as an array to output 0
send_measurement(0, measurements_output)

surf = get_surface(0)

flipped_points = surf.points.copy()
flipped_offset = surf.offset

flipped_points[flipped_points != -32768] *= -1
flipped_offset.x += surf.header.bounding_box.width

send_surface(0, flipped_offset, surf.scale, flipped_points, surf.intensity)

surf = get_surface(0)

s = surf.points[surf.points != -32768]

max_z = numpy.max(s) * surf.scale.z + surf.offset.z
min_z = numpy.min(s) * surf.scale.z + surf.offset.z

send_measurement(0, min_z)
send_measurement(1, max_z)

x = numpy.linspace(-15, 15, 10) # 10 points spanning 0..30 mm range
y = numpy.linspace(-15, 15, 10) # 10 points spanning 0..30 mm range

xv, yv = numpy.meshgrid(x, y)

send_measurement(0, xv.flatten())
send_measurement(1, yv.flatten())

im0 = get_image(0)
im1 = get_image(1)

delta = im0.pixels.astype(numpy.float32) - im1.pixels.astype(numpy.float32)
stdev = numpy.std(delta)

new_pixels = numpy.clip(delta / (2*stdev) * 128 + 128, 0, 255).astype(numpy.uint8)

send_image(0, new_pixels, PixelFormat.RGB_8)
send_measurement(1, stdev)

# Script (using built in urlib package)
import urllib.request
import json
import numpy as np

# Assuming get_image(0).pixels returns a numpy array
array = get_image(0).pixels
array_bytes = array.tobytes()

# Encode shape information as JSON in the headers
headers = {'Content-Type': 'application/octet-stream', 'X-Array-Shape': json.dumps(array.shape)}
url = 'http://127.0.0.1:5000/receive_array'

# Encode array bytes data and prepare request
req = urllib.request.Request(url, data=array_bytes, headers=headers)
urllib.request.urlopen(req)


# SERVER (server.py)

from flask import Flask, request, Response
import numpy as np
import cv2
import json

app = Flask(__name__)

@app.route('/receive_array', methods=['POST'])
def receive_array():
    # Get the content of the request
    data = request.data

    # Extract shape information from headers
    shape_info = json.loads(request.headers.get('X-Array-Shape'))
    height, width, channels = shape_info

    # Extract image bytes
    image_array = np.frombuffer(data, dtype=np.uint8)
    image_array = image_array.reshape((height, width, channels))

    # Display image
    #cv2.imshow('Received Image', image_array)
    #cv2.waitKey(0)
    #cv2.destroyAllWindows()

    # Print size of received image
    print("Received image size:", image_array.shape)

    return Response(status=200)

if __name__ == '__main__':
    app.run(debug=False, threaded=True, port=5000)

# SAMPLE CONSOLE CLIENT (client.py)
# A standalone demonstration of the functionality used by the image HTTP  
# forwarding script.

import requests
import numpy as np
import json

# Assuming you have a function to generate numpy arrays as images
def generate_numpy_array():
    # Generating a sample numpy array
    array = np.random.rand(100, 100, 3) * 255  # Random 100x100x3 array of floats between 0 and 255
    return array.astype(np.uint8)

def send_array_to_server(array):
    url = 'http://127.0.0.1:5000/receive_array'
    array_bytes = array.tobytes()

    # Encode shape information as JSON in the headers
    headers = {'Content-Type': 'application/octet-stream', 'Array-Shape': json.dumps(array.shape)}

    response = requests.post(url, data=array_bytes, headers=headers)

# Generate and send arrays to the server
while True:
    array = generate_numpy_array()
    send_array_to_server(array)

# Save profile template to disk
import csv

profile = get_profile(0)
points = profile.points

template_path = r'C:\GoTools\Script\profile.csv'
numpy.savetxt(template_path, points, delimiter=',', fmt='%d')

send_measurement(0, 1)

# Load and correct
import csv

profile = get_profile(0)
points = profile.points

# load template
template_path = r'C:\GoTools\Script\profile_template.csv'

if 'template' not in memory:
    template_points = numpy.genfromtxt(template_path, delimiter=',', dtype=numpy.int16)
    memory['template'] = template_points
    log_info("Loaded template")
else:    
    template_points = memory['template']

# subtract while handling null values
mask = (template_points != -32768) & (points != -32768)
result = numpy.full_like(points, -32768)
numpy.subtract(points, template_points, out=result, where=mask, dtype=numpy.int16)

send_profile(0, profile.offset, profile.scale, result)

# optionally send original profile and template as outputs
send_profile(1, profile.offset, profile.scale, points)
send_profile(2, profile.offset, profile.scale, template_points)

# optionally save all three into a new CSV file

output_path = r'C:\GoTools\Script\profile_log.csv'
combined_array = numpy.vstack((points, template_points, result)).T

with open(output_path, 'w', newline='') as csv_file:
    writer = csv.writer(csv_file)
    writer.writerow(['Profile', 'Template', 'Difference'])
    writer.writerows(combined_array)

from inspect import signature

log_error(str(signature(send_measurement)))

import numpy as np
import csv
import os
from ftplib import FTP

from datetime import datetime

surface = get_surface(0)

xRes = surface.scale.x
yRes = surface.scale.y
zRes = surface.scale.z
xOff = surface.offset.x
yOff = surface.offset.y
zOff = surface.offset.z
length = surface.points.shape[0]
width = surface.points.shape[1]
size = width*length

# scale Z points to engineering units
Z = surface.points.copy()
Z = Z.astype(np.double)
Z.setflags(write=1)
Z[Z==-32768] = np.nan  
Z = Z*zRes+zOff
Z = np.round(Z, 10)

# 1D array example:
# generate X array
Xarr = (np.asarray(range(width), dtype=np.double) * xRes) + xOff
Xarr = np.tile(Xarr, length)
# generate Y array
Yarr = (np.arange(length, dtype=np.double)* yRes) + yOff
Yarr = np.repeat(Yarr, repeats=width)
# flatten and generate Z array
Zarr = Z
Zarr = Zarr.flatten()
Zarr = (Zarr * zRes) + zOff   
# stack arrays
data_3DXYZ = np.stack((Xarr,Yarr,Zarr), axis = 1)
data_3DXYZ = data_3DXYZ.round()

# generate local path
now = datetime.now()
unique_filename = now.strftime("%Y-%m-%d_%H-%M-%S_XYZ.npy")
documents_path = os.path.join(os.environ['USERPROFILE'], 'Documents')
writePath = os.path.join(documents_path,unique_filename)

# save numpy file, default example
np.save(writePath,data_3DXYZ)

# save csv file
#with open(writePath,'w',newline='') as csvfile:
#    writer = csv.writer(csvfile,delimiter=',')
#    writer.writerow(["X","Y","Z"])
#    writer.writerows(data_3DXYZ)


# 2D array example:
'''
# Custom header elements for post processing
header_title_elements = ["xRes", "yRes", "zRes",
                        "xOff", "yOff", "zOff",
                        "length","width","size"]
header_title_string = ','.join(header_title_elements)

header_elements = [str(xRes), str(yRes), str(zRes), 
                   str(xOff), str(yOff),str(zOff), 
                   str(length), str(width), str(size)]
header_data_string = ','.join(header_elements)

# generate local path
now = datetime.now()
unique_filename = now.strftime("%Y-%m-%d_%H-%M-%S_XYZ.csv")
documents_path = os.path.join(os.environ['USERPROFILE'], 'Documents')
writePath = os.path.join(documents_path,unique_filename)

# Write the headers to the file
#with open(writePath, 'w') as f:
#    f.write(header_title_string + '\n')  # First line of headers (titles)
#    f.write(header_data_string + '\n')   # Second line of headers (actual values)

#with open(writePath, 'ab') as f:  # Open as binary to avoid issues across different Python versions
#    np.savetxt(f, Z, delimiter=',', fmt='%s')
'''

#Send file over FTP

# FTP server details
ftp_host = '127.0.0.1'
ftp_username = 'tester'
ftp_password = 'password'
file_path = writePath  # The local path to your file
remote_path = '/' + unique_filename  # The remote path where you want to upload the file
 
# Establish FTP connection and login
if 'FTP' not in memory: 
    ftp = FTP(ftp_host)
    ftp.login(ftp_username, ftp_password)
    memory['FTP'] = ftp
ftp = memory['FTP']

try:
    # Open the file in binary read mode
    with open(file_path, 'rb') as file:
        ftp.storbinary(f'STOR {remote_path}', file)
except Exception as e:
    log_info(f"An error occurred: {e}")