documentation technical

news media journalism

government public service

technology software

healthcare medical

English

The domain name 'reasonable-orange-yvczxje869-qa9m9ng2su.edgeone.app' uses the application-focused generic top-level domain (.app); it also runs on subdomain 'reasonable-orange-yvczxje869-qa9m9ng2su'. Count 7 characters in 'edgeone' containing 4 vowels alongside 3 consonants. Tokenizing the label suggests two words: edge, one. Median word length is 3.5 characters. No strong language cues emerged from the frequency lists.

html/4a/8a/4a8a8952-e388-4de7-9c35-5adaaca5d198.html.gz

3d0522374f2b299b26783d49325bfda9bc6456804de48e9392debf3c5450018d

ee14cd241f693504a9ea55fa2f2ed3b24da1f7cf804926716069d0d232434d8e

a68b21c9553d614384f7f459622e46e02e3c9cfdf7392915a2fa1d615e338473

f7caec36c5653db4a6dc12b357c7a863805c6c0159bf7c6853770ac850db2b26

7ca4bd4f830b0bdf79cc6f94ebf93cb17e74802ef93ae9b6394da373e453542b

7ad3a744e401847d42942ecdc5814147b9245d3498fa87e6b8e480e4f41aafa7

viewport

html/4a/8a/4a8a8952-e388-4de7-9c35-5adaaca5d198_nodriver.html.gz

Gesture Control Particles

Prudence Malinki

MarkMonitor Inc.

edgeone.app

IRT-SG-ACE

ACE administrator

ACE-SG


        import * as THREE from 'https://cdn.skypack.dev/three@0.136.0';

        // --- Configuration ---
        const config = {
            text: "codeninjavik",
            particleColor: 0x8A2BE2,
            particleSize: 1.2,
            sphereRadius: 80,
            morphSpeed: 0.05
        };

        let scene, camera, renderer, particles;
        let currentPositions, targetPositionsSphere, targetPositionsText;
        
        // This variable is now controlled by the Hand AI
        let isMorphingToText = false; 

        initThreeJS();
        initMediaPipe();

        // ---------------------------------------------------------
        // 1. THREE.JS VISUALS
        // ---------------------------------------------------------
        function initThreeJS() {
            scene = new THREE.Scene();
            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
            camera.position.z = 200;

            renderer = new THREE.WebGLRenderer({ antialias: true });
            renderer.setSize(window.innerWidth, window.innerHeight);
            renderer.setPixelRatio(window.devicePixelRatio);
            document.body.appendChild(renderer.domElement);

            // Generate Targets
            targetPositionsText = getTextCoordinates(config.text);
            const particleCount = targetPositionsText.length / 3;
            targetPositionsSphere = getSphereCoordinates(particleCount, config.sphereRadius);

            // Create Particles
            currentPositions = new Float32Array(targetPositionsSphere);
            const geometry = new THREE.BufferGeometry();
            geometry.setAttribute('position', new THREE.BufferAttribute(currentPositions, 3));

            const material = new THREE.PointsMaterial({
                color: config.particleColor,
                size: config.particleSize,
                blending: THREE.AdditiveBlending,
                transparent: true,
                opacity: 0.8,
                depthWrite: false
            });

            particles = new THREE.Points(geometry, material);
            scene.add(particles);

            window.addEventListener('resize', () => {
                camera.aspect = window.innerWidth / window.innerHeight;
                camera.updateProjectionMatrix();
                renderer.setSize(window.innerWidth, window.innerHeight);
            });

            animate();
        }

        function getTextCoordinates(text) {
            const canvas = document.createElement('canvas');
            const ctx = canvas.getContext('2d');
            const fontSize = 60;
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;

            ctx.font = `bold ${fontSize}px Arial`;
            ctx.fillStyle = 'white';
            ctx.textAlign = 'center';
            ctx.textBaseline = 'middle';
            ctx.fillText(text, canvas.width / 2, canvas.height / 2);

            const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height).data;
            const positions = [];
            const step = 3; 

            for (let y = 0; y < canvas.height; y += step) {
                for (let x = 0; x < canvas.width; x += step) {
                    if (imageData[(y * canvas.width + x) * 4] > 0) {
                        positions.push(
                            (x - canvas.width / 2) * 1.5, 
                            -(y - canvas.height / 2) * 1.5, 
                            0
                        );
                    }
                }
            }
            return new Float32Array(positions);
        }

        function getSphereCoordinates(count, radius) {
            const positions = [];
            for (let i = 0; i < count; i++) {
                const phi = Math.acos(-1 + (2 * i) / count);
                const theta = Math.sqrt(count * Math.PI) * phi;
                positions.push(
                    radius * Math.cos(theta) * Math.sin(phi),
                    radius * Math.sin(theta) * Math.sin(phi),
                    radius * Math.cos(phi)
                );
            }
            return new Float32Array(positions);
        }

        function animate() {
            requestAnimationFrame(animate);

            const positions = particles.geometry.attributes.position.array;
            const target = isMorphingToText ? targetPositionsText : targetPositionsSphere;

            for (let i = 0; i < positions.length; i++) {
                positions[i] += (target[i] - positions[i]) * config.morphSpeed;
            }

            particles.rotation.y += 0.002;
            particles.geometry.attributes.position.needsUpdate = true;
            renderer.render(scene, camera);
        }

        // ---------------------------------------------------------
        // 2. MEDIAPIPE HAND TRACKING
        // ---------------------------------------------------------
        function initMediaPipe() {
            const videoElement = document.getElementById('input_video');
            const statusElement = document.getElementById('status');

            const hands = new Hands({locateFile: (file) => {
                return `https://cdn.jsdelivr.net/npm/@mediapipe/hands/${file}`;
            }});

            hands.setOptions({
                maxNumHands: 1,
                modelComplexity: 1,
                minDetectionConfidence: 0.5,
                minTrackingConfidence: 0.5
            });

            hands.onResults((results) => {
                document.getElementById('loading').style.display = 'none';

                if (results.multiHandLandmarks && results.multiHandLandmarks.length > 0) {
                    const landmarks = results.multiHandLandmarks[0];

                    // Get Thumb Tip (Index 4) and Index Finger Tip (Index 8)
                    const thumbTip = landmarks[4];
                    const indexTip = landmarks[8];

                    // Calculate distance between thumb and index
                    const distance = Math.sqrt(
                        Math.pow(thumbTip.x - indexTip.x, 2) + 
                        Math.pow(thumbTip.y - indexTip.y, 2)
                    );

                    // THRESHOLD LOGIC:
                    // If distance is small (< 0.05), it's a pinch.
                    // If distance is large (> 0.05), it's an open hand.
                    if (distance < 0.05) {
                        isMorphingToText = false; // Pinch = Sphere
                        statusElement.innerText = "State: Sphere (Pinch detected)";
                    } else {
                        isMorphingToText = true;  // Open = Text
                        statusElement.innerText = "State: Text (Open hand detected)";
                    }
                } else {
                    statusElement.innerText = "No hand detected";
                }
            });

            const camera = new Camera(videoElement, {
                onFrame: async () => {
                    await hands.send({image: videoElement});
                },
                width: 640,
                height: 480
            });
            
            camera.start();
        }
    

jsDelivr

✅ Low Risk - https://reasonable-orange-yvczxje869-qa9m9ng2su.edgeone.app/

Requests	IP Address	Location	AS Autonomous System
3	104.26.12.82	United States	AS13335CLOUDFLARENET
2	43.152.26.58	Singapore	AS139341ACE
2	151.101.1.229	United States	AS54113FASTLY
7	3	-	-

Security Scan Report: reasonable-orange-yvczxje869-qa9m9ng2su.edgeone.app

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies1

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History