Retour
Site internet
La Chablisienne, référence historique du vignoble chablisien, incarne l’excellence collective et la précision du terroir.
Nous avons conçu un site de positionnement de marque qui traduit son identité : élégance, authenticité et maîtrise technique.
Le site e-commerce a été entièrement connecté à l’ERP, permettant la synchronisation et gestion des commandes, le paiement en ligne sécurisé et la mise à disposition d'outils emarketing.
Nous avons également mis en place une stratégie digitale, incluant la réalisation d'un espace “Offres Privilèges” dédié à la fidélisation des clients et des professionnels, dans une expérience fluide et raffinée.
Un projet où la technologie s’efface derrière la justesse du ton et la force du vin.
Nous avons conçu un site de positionnement de marque qui traduit son identité : élégance, authenticité et maîtrise technique.
Le site e-commerce a été entièrement connecté à l’ERP, permettant la synchronisation et gestion des commandes, le paiement en ligne sécurisé et la mise à disposition d'outils emarketing.
Nous avons également mis en place une stratégie digitale, incluant la réalisation d'un espace “Offres Privilèges” dédié à la fidélisation des clients et des professionnels, dans une expérience fluide et raffinée.
Un projet où la technologie s’efface derrière la justesse du ton et la force du vin.
// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)
// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d// compiled preview • scanner demo /* generated for visual effect
– not executed */ const SCAN_WIDTH = 8; const FADE_ZONE = 35; cons
t MAX_PARTICLES = 2500; const TRANSITION = 0.05; function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now(
); function rng(min, max) { return Math.random() * (max - min) + m
in; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a
; } step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; t
his.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } s
tep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } clas
s Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(d
t) { this.x += this.vx * dt; this.y += this.vy * dt; } } const sca
nner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH,
glow: 3.5, }; function drawParticle(ctx, p) { ctx.globalAlpha = cl
amp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p.r, p.y - p.r, p.r
* 2, p.r * 2); } function tick(t) { // requestAnimationFrame(tick)// React Scanner Component import React, { useState, useEffect } f
rom 'react'; const Scanner = ({ image, onTransform }) => { const [
position, setPosition] = useState(0); const [isScanning, setIsScan
ning] = useState(false); useEffect(() => { const animate = () => {
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } const now = () =
> performance.now(); function rng(min, max) { return Math.random()
* (max - min) + min; } class Particle0 { constructor(x, y, vx, vy
, r, a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this
.r = r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y +=
this.vy * dt; } } class Particle1 { constructor(x, y, vx, vy, r,
a) { this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r =
r; this.a = a; } step(dt) { this.x += this.vx * dt; this.y += this
.vy * dt; } } class Particle2 { constructor(x, y, vx, vy, r, a) {
this.x = x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; th
is.a = a; } step(dt) { this.x += this.vx * dt; this.y += this.vy *
dt; } } const scanner = { x: Math.floor(window.innerWidth / 2), w
idth: SCAN_WIDTH, glow: 3.5, }; function drawParticle(ctx, p) { ct
x.globalAlpha = clamp(p.a, 0, 1); ctx.drawImage(gradient, p.x - p./* Scanner Animation Styles */ .scanner-container { display: flex;
height: 100vh; } .scanner-bar { width: 8px; background: linear-gr
adient( to bottom, transparent 0%, #00FEBA 20%, #00FEBA 80%, trans
parent 100% ); box-shadow: 0 0 20px #00FEBA; animation: scan 2s li
near infinite; } @keyframes scan { 0% { transform: translateX(-100
vw); } 100% { transform: translateX(100vw); } } function clamp(n,
a, b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b,
t) { return a + (b - a) * t; } const now = () => performance.now()
; function rng(min, max) { return Math.random() * (max - min) + mi
n; } class Particle0 { constructor(x, y, vx, vy, r, a) { this.x =
x; this.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a;
} step(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } }
class Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; th
is.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } st
ep(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y
= y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt
) { this.x += this.vx * dt; this.y += this.vy * dt; } } const scan
ner = { x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, g// Three.js Scanner Effect import * as THREE from 'three'; class S
cannerEffect { constructor() { this.scene = new THREE.Scene(); thi
s.camera = new THREE.PerspectiveCamera(75, window.innerWidth / win
dow.innerHeight, 0.1, 1000); this.renderer = new THREE.WebGLRender
er({ alpha: true }); this.particles = []; this.init(); } init() {
this.createParticles(); this.animate(); } function clamp(n, a, b)
{ return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => performance.now(); func
tion rng(min, max) { return Math.random() * (max - min) + min; } c
lass Particle0 { constructor(x, y, vx, vy, r, a) { this.x = x; thi
s.y = y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } ste
p(dt) { this.x += this.vx * dt; this.y += this.vy * dt; } } class
Particle1 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y =
y; this.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt)
{ this.x += this.vx * dt; this.y += this.vy * dt; } } class Parti
cle2 { constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; t
his.vx = vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { th
is.x += this.vx * dt; this.y += this.vy * dt; } } const scanner =
{ x: Math.floor(window.innerWidth / 2), width: SCAN_WIDTH, glow: 3// Image Processing Algorithm function processImage(imageData) { c
onst canvas = document.createElement('canvas'); const ctx = canvas
.getContext('2d'); const data = imageData.data; for (let i = 0; i
< data.length; i += 4) { const gray = data[i] * 0.299 + data[i + 1
] * 0.587 + data[i + 2] * 0.114; data[i] = gray; data[i + 1] = gra
y; data[i + 2] = gray; } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a)
* t; } const now = () => performance.now(); function rng(min, max
) { return Math.random() * (max - min) + min; } class Particle0 {
constructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx
= vx; this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x +=
this.vx * dt; this.y += this.vy * dt; } } class Particle1 { const
ructor(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx;
this.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this
.vx * dt; this.y += this.vy * dt; } } class Particle2 { constructo
r(x, y, vx, vy, r, a) { this.x = x; this.y = y; this.vx = vx; this
.vy = vy; this.r = r; this.a = a; } step(dt) { this.x += this.vx *
dt; this.y += this.vy * dt; } } const scanner = { x: Math.floor(w
indow.innerWidth / 2), width: SCAN_WIDTH, glow: 3.5, }; function d
Prêt·e à révéler et faire rayonner votre marque ?
Parlons objectifs, images qui marquent et résultats mesurables. Un premier call pour cadrer le défi et imaginer la suite.
