FME Geometry, PythonCaller, GenerativeArt


#main_script
import fmeobjects
import numpy as np
from fmeobjects import FMELine, FMEPoint, FMEPolygon
import numpy as np
import math
import numpy as np
from sklearn.cluster import KMeans
from sklearn.neighbors import KDTree
from sklearn.manifold import TSNE


def generate_tsne_network(n_points=200, n_clusters=5, n_neighbors=3,
                          n_dims_raw=7, perplexity=30, seed=42):
    """
    NOTICE I USE LOW PERPLEXITY
    Generate a network of connected points using t-SNE for dimensionality reduction:
    random high-dim points  cluster  connect neighbors  reduce with t-SNE  return edges.
    """
    rng = np.random.RandomState(seed)

   
    raw_points = rng.randn(n_points, n_dims_raw)

   
    labels = KMeans(n_clusters=n_clusters, random_state=seed, n_init=4) \
        .fit_predict(raw_points)

    
    tree = KDTree(raw_points)
    _, indices = tree.query(raw_points, k=n_neighbors + 1)

    edges_idx = set()
    for i, neighbors in enumerate(indices):
        for j in neighbors[1:]:
            edges_idx.add((min(i, j), max(i, j)))

   
    tsne = TSNE(n_components=2, perplexity=perplexity, random_state=seed)
    points_2d = tsne.fit_transform(raw_points)

    
    edges = [
        ((float(points_2d[i][0]), float(points_2d[i][1])),
         (float(points_2d[j][0]), float(points_2d[j][1])))
        for i, j in edges_idx
    ]

    return edges

class FeatureProcessor(object):
    def __init__(self):
        pass

    def input(self, feature: fmeobjects.FMEFeature):
        lines = generate_tsne_network(n_points=33, n_clusters=5, n_neighbors=3,
                          n_dims_raw=10, perplexity=2, seed=42)
        # output the star boundary
        for i,line in enumerate(lines):
            tri_ring = (list(map(tuple, line)))
            tri_line = FMELine([tuple(p) for p in tri_ring])
            out_feat = fmeobjects.FMEFeature(feature)
            out_feat.setGeometry(tri_line)
            
            self.pyoutput(out_feat)