GoCaptcha

https://github.com/wenlng/go-captcha
Admin
GoCaptcha is a powerful, modular, and highly customizable behavioral CAPTCHA library that supports...
Tokens:47,356
Snippets:594
Trust Score:8.3
License:Apache-2.0
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example GraphImage Initialization

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/types.md

Example of initializing a GraphImage struct with image components.

```go
graphImage := &slide.GraphImage{
    OverlayImage: tileImg,
    ShadowImage: shadowImg,
    MaskImage: maskImg,
}
```

--------------------------------

### Complete Example: Creating All CAPTCHA Types

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

This example demonstrates how to initialize and generate all supported CAPTCHA types: text-mode click, shape-mode click, slide, and rotate. It covers loading resources, configuring builders, and generating CAPTCHA data. Ensure all necessary resources like fonts and images are available.

```go
package main

import (
    "encoding/json"
    "fmt"
    "image"
    "log"

    "github.com/golang/freetype/truetype"
    "github.com/wenlng/go-captcha/v2"
    "github.com/wenlng/go-captcha/v2/base/option"
    "github.com/wenlng/go-captcha/v2/click"
    "github.com/wenlng/go-captcha/v2/slide"
    "github.com/wenlng/go-captcha/v2/rotate"
)

var (
    textCaptcha  click.Captcha
    shapeCaptcha click.Captcha
    slideCaptcha slide.Captcha
    rotateCaptcha rotate.Captcha
)

func init() {
    // Load resources (pseudo-code)
    font := loadFont("font.ttf")
    bgImage := loadImage("background.jpg")
    shapeImages := loadShapeImages()
    tileGraphics := loadTileGraphics()
    
    // Initialize Click CAPTCHA (Text Mode)
    textBuilder := v2.NewClickBuilder(
        click.WithRangeLen(option.RangeVal{Min: 4, Max: 6}),
        click.WithImageSize(option.Size{Width: 300, Height: 220}),
    )
    textBuilder.SetResources(
        click.WithChars([]string{"A", "B", "C", "D", "E"}),
        click.WithFonts([]*truetype.Font{font}),
        click.WithBackgrounds([]image.Image{bgImage}),
    )
    textCaptcha = textBuilder.Make()
    
    // Initialize Click CAPTCHA (Shape Mode)
    shapeBuilder := v2.NewClickBuilder()
    shapeBuilder.SetResources(
        click.WithShapes(shapeImages),
        click.WithBackgrounds([]image.Image{bgImage}),
    )
    shapeCaptcha = shapeBuilder.MakeShape()
    
    // Initialize Slide CAPTCHA
    slideBuilder := v2.NewSlideBuilder(
        slide.WithImageSize(option.Size{Width: 300, Height: 220}),
    )
    slideBuilder.SetResources(
        slide.WithBackgrounds([]image.Image{bgImage}),
        slide.WithGraphImages(tileGraphics),
    )
    slideCaptcha = slideBuilder.Make()
    
    // Initialize Rotate CAPTCHA
    rotateBuilder := v2.NewRotateBuilder(
        rotate.WithImageSquareSize(220),
    )
    rotateBuilder.SetResources(
        rotate.WithImages([]image.Image{bgImage}),
    )
    rotateCaptcha = rotateBuilder.Make()
}

func main() {
    // Generate text-mode click CAPTCHA
    textData, err := textCaptcha.Generate()
    if err != nil {
        log.Fatal(err)
    }
    
    dots := textData.GetData()
    masterBase64, _ := textData.GetMasterImage().ToBase64()
    thumbBase64, _ := textData.GetThumbImage().ToBase64()
    
    dotsJSON, _ := json.Marshal(dots)
    fmt.Printf("Text CAPTCHA - Dots: %s\n", string(dotsJSON))
    fmt.Printf("Text CAPTCHA - Master: %s\n", masterBase64)
    fmt.Printf("Text CAPTCHA - Thumb: %s\n", thumbBase64)
    
    // Generate shape-mode click CAPTCHA
    shapeData, err := shapeCaptcha.Generate()
    if err != nil {
        log.Fatal(err)
    }
    
    // Generate slide CAPTCHA
    slideData, err := slideCaptcha.Generate()
    if err != nil {
        log.Fatal(err)
    }
    
    block := slideData.GetData()
    fmt.Printf("Slide CAPTCHA - Target: X=%d, Y=%d\n", block.X, block.Y)
    
    // Generate rotate CAPTCHA
    rotateData, err := rotateCaptcha.Generate()
    if err != nil {
        log.Fatal(err)
    }
    
    block = rotateData.GetData()
    fmt.Printf("Rotate CAPTCHA - Target Angle: %d\n", block.Angle)
}

```

--------------------------------

### Example Block Initialization

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/types.md

Example of how to initialize a Block struct for Slide CAPTCHA.

```go
block := &slide.Block{
    X: 150,
    Y: 100,
    Width: 50,
    Height: 50,
    DX: 160,
    DY: 110,
}
```

--------------------------------

### Example Usage of Size

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/types.md

Shows how to initialize a Size struct for specifying image dimensions.

```go
imageSize := option.Size{Width: 300, Height: 220}
```

--------------------------------

### Install go-captcha

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Install the latest version of the go-captcha library using go get.

```shell
go get -u github.com/wenlng/go-captcha/v2@latest
```

--------------------------------

### Example Usage of Point

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/types.md

Demonstrates initializing a Point struct to define a shadow offset.

```go
shadowOffset := option.Point{X: 3, Y: 3}
```

--------------------------------

### Set Captcha Options Example

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/types.md

Example of applying multiple option functions to configure image size and character range for the captcha.

```go
builder.SetOptions(
    click.WithImageSize(option.Size{Width: 300, Height: 220}),
    click.WithRangeLen(option.RangeVal{Min: 4, Max: 6}),
)
```

--------------------------------

### Set Captcha Resources Example

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/types.md

Example of applying resource functions to set custom characters, fonts, and background images for the captcha.

```go
builder.SetResources(
    click.WithChars([]string{"A", "B", "C"}),
    click.WithFonts([]*truetype.Font{font1}),
    click.WithBackgrounds([]image.Image{bgImage}),
)
```

--------------------------------

### Example Usage of RangeVal

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/types.md

Illustrates how to initialize and use the RangeVal struct for defining a length range.

```go
rangeLen := option.RangeVal{Min: 4, Max: 6}
```

--------------------------------

### Set Builder Options

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Append or modify builder configurations using `SetOptions`. This example sets the range length and enables display shadow.

```go
builder.SetOptions(
    click.WithRangeLen(option.RangeVal{Min: 2, Max: 5}),
    click.WithDisplayShadow(true),
)
```

--------------------------------

### Instantiate Rotate CAPTCHA Block

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/types.md

Example of creating a Block instance for Rotate CAPTCHA verification data.

```go
block := &rotate.Block{
    Width: 100,
    Height: 100,
    Angle: 45,
}
```

--------------------------------

### Initialize Click CAPTCHA Builder

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/configuration.md

Use builder methods to set Click CAPTCHA options. This example initializes the builder and sets the image size.

```go
builder := click.NewBuilder(
    click.WithImageSize(option.Size{Width: 300, Height: 220}),
)
builder.SetOptions(click.WithRangeLen(option.RangeVal{Min: 4, Max: 6}))
```

--------------------------------

### Go Captcha Usage Example

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/imagedata.md

Demonstrates how to generate a CAPTCHA, export its master and thumbnail images, and save them to files or retrieve them as Base64 strings or raw bytes with specified quality.

```go
package main

import (
    "log"
    "github.com/wenlng/go-captcha/v2/base/option"
    "github.com/wenlng/go-captcha/v2/click"
)

func main() {
    // Generate CAPTCHA
    builder := click.NewBuilder()
    // ... configure builder ...
    capt := builder.Make()
    captData, err := capt.Generate()
    if err != nil {
        log.Fatal(err)
    }

    // Export master image (JPEG)
    masterImg := captData.GetMasterImage()
    
    // Option 1: Get as Base64 for embedding in HTML
    base64Str, err := masterImg.ToBase64() 
    
    // Option 2: Save to file
    err = masterImg.SaveToFile("/tmp/master.jpg", option.QualityLevel2) 
    
    // Option 3: Get raw bytes for streaming
    jpegBytes, err := masterImg.ToBytesWithQuality(option.QualityLevel3)

    // Export thumbnail image (PNG)
    thumbImg := captData.GetThumbImage()
    
    // PNG supports transparency, so save as PNG
    err = thumbImg.SaveToFile("/tmp/thumb.png") 
    
    // Or get as Base64 for HTML
    thumbBase64, err := thumbImg.ToBase64()
}
```

--------------------------------

### Generate Click CAPTCHA Data and Images

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

This example demonstrates how to generate Click CAPTCHA data, including target coordinates, master image, and thumbnail image. It also shows how to convert images to base64 strings and save them to files.

```go
package main

import (
	"encoding/json"
	"fmt"
	"image"
	"log"
	"io/ioutil"

	"github.com/golang/freetype"
	"github.com/golang/freetype/truetype"
	"github.com/wenlng/go-captcha/v2/base/option"
	"github.com/wenlng/go-captcha/v2/click"
	"github.com/wenlng/go-captcha/v2/base/codec"
)

var textCapt click.Captcha

func init() {
	builder := click.NewBuilder(
		click.WithRangeLen(option.RangeVal{Min: 4, Max: 6}),
		click.WithRangeVerifyLen(option.RangeVal{Min: 2, Max: 4}),
	)

	// You can use preset material resources：https://github.com/wenlng/go-captcha-assets
	fontN, err := loadFont("../resources/fzshengsksjw_cu.ttf")
	if err != nil {
		log.Fatalln(err)
	}

	bgImage, err := loadPng("../resources/bg.png")
	if err != nil {
		log.Fatalln(err)
	}

	builder.SetResources(
		click.WithChars([]string{
			"1A",
			"5E",
			"3d",
			"0p",
			"78",
			"DL",
			"CB",
			"9M",
			// ...
		}),
		click.WithFonts([]*truetype.Font{
			fontN,
		}),
		click.WithBackgrounds([]image.Image{
			bgImage,
		}),
	)

	textCapt= builder.Make()
}

func loadPng(p string) (image.Image, error) {
	imgBytes, err := ioutil.ReadFile(p)
	if err != nil {
		return nil, err
	}
	return codec.DecodeByteToPng(imgBytes)
}

func loadFont(p string) (*truetype.Font, error) {
	fontBytes, err := ioutil.ReadFile(p)
	if err != nil {
		panic(err)
	}
	return freetype.ParseFont(fontBytes)
}


func main() {
	captData, err := textCapt.Generate()
	if err != nil {
		log.Fatalln(err)
	}

	dotData := captData.GetData()
	if dotData == nil {
		log.Fatalln(">>>>> generate err")
	}

	dots, _ := json.Marshal(dotData)
	fmt.Println(">>>>> ", string(dots))

	var mBase64, tBase64 string
	mBase64, err = captData.GetMasterImage().ToBase64()
	if err != nil {
		fmt.Println(err)
	}
	tBase64, err = captData.GetThumbImage().ToBase64()
	if err != nil {
		fmt.Println(err)
	}
	
	fmt.Println(">>>>> ", mBase64)
	fmt.Println(">>>>> ", tBase64)
	
	//err = captData.GetMasterImage().SaveToFile("../resources/master.jpg", option.QualityNone)
	//if err != nil {
	//	fmt.Println(err)
	//}
	//err = captData.GetThumbImage().SaveToFile("../resources/thumb.png")
	//if err != nil {
	//	fmt.Println(err)
	//}
}
```

--------------------------------

### Get go-captcha V2 Module Version

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Retrieves the current version string of the go-captcha V2 module.

```go
const Version = "2.0.4"
```

--------------------------------

### Separate Resource and CAPTCHA Validation

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/errors.md

Distinguish between resource validation, which occurs at setup time (e.g., checking character count), and CAPTCHA validation, which happens at runtime (e.g., validating user input).

```go
// Resource validation (setup-time)
if len(chars) <= maxRangeLen {
    return errors.New("insufficient characters")
}

// CAPTCHA validation (runtime)
valid := click.Validate(userX, userY, dotX, dotY, width, height, padding)
if !valid {
    fmt.Println("Validation failed")
}
```

--------------------------------

### Convert JPEG to Base64 String (with Data URI)

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/imagedata.md

Use ToBase64 to get a Base64 encoded string of the JPEG image, including the "data:image/jpeg;base64," prefix. Handles potential errors.

```go
base64Str, err := jpegData.ToBase64()
if err != nil {
    log.Fatal(err)
}
// Use in HTML: <img src="base64Str"/>
```

--------------------------------

### Get Master Image Data - Go

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/rotate.md

Retrieves the main background image in PNG format, which has been rotated at the target angle. Provides methods to convert to base64 or bytes.

```go
masterImg := captData.GetMasterImage()
pngBase64, err := masterImg.ToBase64()
pngBytes, err := masterImg.ToBytes()
```

--------------------------------

### Get Thumbnail Captcha Image

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Retrieve the thumbnail captcha image in PNG format. This is a smaller version of the main captcha.

```go
captData.GetThumbImage()
```

--------------------------------

### Standard Workflow for Click CAPTCHA Builder

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Demonstrates the standard builder pattern for creating a click CAPTCHA. This involves creating a builder, setting options and resources, making the CAPTCHA instance, generating data, and accessing the results.

```go
import (
    "github.com/wenlng/go-captcha/v2"
    "github.com/wenlng/go-captcha/v2/click"
    "github.com/golang/freetype/truetype"
    "image"
)

// Assume font and bgImage are pre-defined image.Image and *truetype.Font variables
var font *truetype.Font
var bgImage image.Image

// 1. Create builder (optionally with initial options)
builder := v2.NewClickBuilder()

// 2. Add/set additional options
builder.SetOptions(
    click.WithDisplayShadow(true),
    click.WithImageAlpha(0.9),
)

// 3. Set resources
builder.SetResources(
    click.WithChars([]string{"A", "B", "C"}),
    click.WithFonts([]*truetype.Font{font}),
    click.WithBackgrounds([]image.Image{bgImage}),
)

// 4. Create CAPTCHA instance (configure mode-specific behavior)
capt := builder.Make()  // or MakeShape(), MakeDragDrop(), etc.

// 5. Generate CAPTCHA data
captData, err := capt.Generate()
if err != nil {
    return err
}

// 6. Access generated data
dots := captData.GetData()
masterImg := captData.GetMasterImage()
thumbImg := captData.GetThumbImage()
```

--------------------------------

### Get Master Captcha Image

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Retrieve the main captcha image in JPEG format. This is the primary image presented to the user.

```go
captData.GetMasterImage()
```

--------------------------------

### Get Captcha Verification Data

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Retrieve the verification data associated with the captcha. This data is typically used for validating user input.

```go
captData.GetData()
```

--------------------------------

### Setting Go-Captcha Resources with Functional Options

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/README.md

Shows how to define and set resources for a CAPTCHA, such as character sets and background images, using functional options.

```go
type Resource func(*Resources)
builder.SetResources(
    WithChars([]string{"A", "B", "C"}),
    WithBackgrounds([]image.Image{img1}),
)
```

--------------------------------

### Get CAPTCHA Block Data - Go

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/rotate.md

Retrieves the block data which contains the target rotation angle, width, and height for verification.

```go
block := captData.GetData()
fmt.Printf("Target angle: %d degrees\n", block.Angle)
fmt.Printf("Thumbnail size: %dx%d\n", block.Width, block.Height)
```

--------------------------------

### Configuration Options

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Options are applied using the builder or SetOptions methods. All options use the functional option pattern.

```APIDOC
## Configuration Options

### Image Options

#### WithImageSize(option.Size)

Sets the main background image dimensions. Default: 300x220.

```go
slide.WithImageSize(option.Size{Width: 300, Height: 220})
```

#### WithImageAlpha(float64)

Sets the main background image transparency (0.0 to 1.0).

```go
slide.WithImageAlpha(0.9)
```

### Graph/Puzzle Piece Options

#### WithRangeGraphSize(option.RangeVal)

Sets the range for random puzzle piece size.

```go
slide.WithRangeGraphSize(option.RangeVal{Min: 40, Max: 80})
```

#### WithRangeGraphAnglePos([]option.RangeVal)

Sets the range for random rotation angles for puzzle pieces.

```go
slide.WithRangeGraphAnglePos([]option.RangeVal{
    {Min: -20, Max: 20},
})
```

#### WithGenGraphNumber(int)

Sets the number of puzzle pieces to generate (minimum 1).

```go
slide.WithGenGraphNumber(1)
```

#### WithEnableGraphVerticalRandom(bool)

When false, puzzle pieces maintain consistent vertical positioning. When true, allows random vertical positioning (drag mode specific).

```go
slide.WithEnableGraphVerticalRandom(false)
```

#### WithRangeDeadZoneDirections([]slide.DeadZoneDirectionType)

Sets the dead zones where the puzzle piece cannot be placed. Available directions: `DeadZoneDirectionTypeLeft`, `DeadZoneDirectionTypeRight`, `DeadZoneDirectionTypeTop`, `DeadZoneDirectionTypeBottom`.

```go
slide.WithRangeDeadZoneDirections([]slide.DeadZoneDirectionType{
    slide.DeadZoneDirectionTypeLeft,
})
```
```

--------------------------------

### Retrieve Underlying Image

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/imagedata.md

The Get method returns the original image.Image object wrapped by the JPEGImageData interface. You can then access its properties like Bounds.

```go
img := jpegData.Get()
bounds := img.Bounds()
```

--------------------------------

### Configure Click CAPTCHA Resources

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/configuration.md

Set resources for click CAPTCHAs using WithChars, WithShapes, WithFonts, and WithBackgrounds. Ensure at least one of WithChars or WithShapes is provided, along with WithFonts and WithBackgrounds.

```go
builder.SetResources(
    click.WithChars([]string{"A", "B", "C"}),
    click.WithShapes(map[string]image.Image{}),
    click.WithFonts([]*truetype.Font{}),
    click.WithBackgrounds([]image.Image{}),
    click.WithThumbBackgrounds([]image.Image{}),
)
```

--------------------------------

### Create Click CAPTCHA Builder

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Use `NewBuilder` to create a builder instance. Configure image size and range length with options.

```go
import "github.com/wenlng/go-captcha/v2/click"

builder := click.NewBuilder(
    click.WithImageSize(option.Size{Width: 300, Height: 220}),
    click.WithRangeLen(option.RangeVal{Min: 4, Max: 6}),
)
```

--------------------------------

### Get Slide Captcha Master Image

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Retrieves the main background image in JPEG format. The image data can be converted to base64 or raw bytes.

```go
func (c CaptData) GetMasterImage() imagedata.JPEGImageData
```

```go
masterImg := captData.GetMasterImage()
base64Str, err := masterImg.ToBase64()
jpegBytes, err := masterImg.ToBytes()
```

--------------------------------

### Go-Captcha Builder Pattern Overview

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/README.md

Illustrates the typical sequence of calls for creating and generating a CAPTCHA using the builder pattern. This pattern is consistent across different CAPTCHA types.

```go
NewBuilder(opts...) -> Builder
  -> SetOptions(opts...)
  -> SetResources(resources...)
  -> Make() / MakeDragDrop() / MakeShape()
    -> Captcha interface
      -> Generate()
        -> CaptchaData interface
          -> GetData()     // Verification data
          -> GetMasterImage()
          -> GetThumbImage() / GetTileImage()
```

--------------------------------

### Get Slide Captcha Tile Image

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Retrieves the puzzle piece tile image in PNG format. The image data can be converted to base64 or raw bytes.

```go
func (c CaptData) GetTileImage() imagedata.PNGImageData
```

```go
tileImg := captData.GetTileImage()
pngBase64, err := tileImg.ToBase64()
pngBytes, err := tileImg.ToBytes()
```

--------------------------------

### Get Master CAPTCHA Image

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Retrieves the main CAPTCHA image in JPEG format. Provides methods to convert the image to base64, bytes, or save it to a file.

```go
masterImg := captData.GetMasterImage()
base64Str, err := masterImg.ToBase64()
jpegBytes, err := masterImg.ToBytes()
err = masterImg.SaveToFile("/path/to/image.jpg", option.QualityNone)
```

--------------------------------

### Configuring Go-Captcha with Option Functions

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/README.md

Demonstrates how to configure CAPTCHA options using Go's functional option pattern. This is used for setting image dimensions and range values.

```go
type Option func(*Options)
builder.SetOptions(
    WithImageSize(option.Size{Width: 300, Height: 220}),
    WithRangeLen(option.RangeVal{Min: 4, Max: 6}),
)
```

--------------------------------

### Create V2 Click Builder

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Initializes a new click CAPTCHA builder with default options.

```go
builder := v2.NewClickBuilder()
```

--------------------------------

### Get Captcha Verification Data

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Retrieves the verification data as a map of points that users must click. Iterates through the dots to access their coordinates and associated text.

```go
dots := captData.GetData()
for idx, dot := range dots {
    fmt.Printf("Dot %d: X=%d, Y=%d, Text=%s\n", idx, dot.X, dot.Y, dot.Text)
}
```

--------------------------------

### Configuration Options

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Configure the main image and thumbnail properties of the captcha. Options include setting sizes, ranges for content length and angles, colors, shadow effects, and transparency.

```APIDOC
## Configuration Options

### Main Image Options

- `click.WithImageSize(option.Size)`: Set main image size, default 300x220.
- `click.WithRangeLen(option.RangeVal)`: Set range for random content length.
- `click.WithRangeAnglePos([]option.RangeVal)`: Set range for random angles.
- `click.WithRangeSize(option.RangeVal)`: Set range for random content size.
- `click.WithRangeColors([]string)`: Set random colors.
- `click.WithDisplayShadow(bool)`: Enable/disable shadow display.
- `click.WithShadowColor(string)`: Set shadow color.
- `click.WithShadowPoint(option.Point)`: Set shadow offset position.
- `click.WithImageAlpha(float32)`: Set main image transparency.
- `click.WithUseShapeOriginalColor(bool)`: Use original graphic color (valid for graphic mode).

### Thumbnail Options

- `click.WithThumbImageSize(option.Size)`: Set thumbnail size, default 150x40.
- `click.WithRangeVerifyLen(option.RangeVal)`: Set range for random verification content length.
- `click.WithDisabledRangeVerifyLen(bool)`: Disable random verification length, matches main content.
- `click.WithRangeThumbSize(option.RangeVal)`: Set range for random thumbnail content size.
- `click.WithRangeThumbColors([]string)`: Set range for random thumbnail colors.
- `click.WithRangeThumbBgColors([]string)`: Set range for random thumbnail background colors.
- `click.WithIsThumbNonDeformAbility(bool)`: Prevent thumbnail content deformation.
- `click.WithThumbBgDistort(int)`: Set thumbnail background distortion (option.DistortLevel1 to option.DistortLevel5).
- `click.WithThumbBgCirclesNum(int)`: Set number of small circles in thumbnail background.
- `click.WithThumbBgSlimLineNum(int)`: Set number of lines in thumbnail background.
```

--------------------------------

### Get Slide Captcha Block Data

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Retrieves the block data containing the target puzzle position and dimensions. Use this to verify the user's puzzle placement.

```go
func (c CaptData) GetData() *slide.Block
```

```go
block := captData.GetData()
fmt.Printf("Target position: X=%d, Y=%d\n", block.X, block.Y)
fmt.Printf("Display position: DX=%d, DY=%d\n", block.DX, block.DY)
```

--------------------------------

### Import Click CAPTCHA Module

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Import the necessary Click CAPTCHA module for your application. Replace `${click|slide|rotate}` with the specific CAPTCHA type you intend to use.

```go
package main

// Import modules on demand
import "github.com/wenlng/go-captcha/v2/${click|slide|rotate}"

func main(){
   // ...
}
```

--------------------------------

### Set Builder Resources

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Configure resources for the CAPTCHA, such as characters, fonts, and background images, using `SetResources`.

```go
builder.SetResources(
    click.WithChars([]string{"A", "B", "C", "1", "2"}),
    click.WithFonts([]*truetype.Font{font1}),
    click.WithBackgrounds([]image.Image{bgImage}),
)
```

--------------------------------

### Configure Thumbnail Image Size

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Set the size for the thumbnail image. The default thumbnail size is 150x40 pixels.

```go
click.NewBuilder(click.WithThumbImageSize(option.Size))
```

--------------------------------

### Get Thumbnail Image Data - Go

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/rotate.md

Retrieves the circular thumbnail image in PNG format, cropped from the main image with transparency. Provides methods to convert to base64 or bytes.

```go
thumbImg := captData.GetThumbImage()
pngBase64, err := thumbImg.ToBase64()
pngBytes, err := thumbImg.ToBytes()
```

--------------------------------

### Configure Slide CAPTCHA Resources

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/configuration.md

Set resources for slide CAPTCHAs using WithBackgrounds and WithGraphImages. Both require at least one image or GraphImage respectively, with GraphImage needing OverlayImage, ShadowImage, and MaskImage.

```go
builder.SetResources(
    slide.WithBackgrounds([]image.Image{}),
    slide.WithGraphImages([]*slide.GraphImage{}),
)
```

--------------------------------

### Configure Rotate CAPTCHA Resources

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/configuration.md

Set resources for rotate CAPTCHAs using WithImages. Requires at least one image to be provided.

```go
builder.SetResources(
    rotate.WithImages([]image.Image{}),
)
```

--------------------------------

### Create Rotate CAPTCHA Builder

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/rotate.md

Use `NewBuilder` to create a new instance for constructing Rotate CAPTCHAs. Optional configurations can be provided during initialization.

```go
import "github.com/wenlng/go-captcha/v2/rotate"

builder := rotate.NewBuilder(
    rotate.WithImageSquareSize(220),
)
```

--------------------------------

### Direct Module Import for Go Captcha V2

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Shows how to import the Go Captcha V2 module directly for use. This is the most straightforward import method.

```go
import "github.com/wenlng/go-captcha/v2"

builder := v2.NewClickBuilder()
```

--------------------------------

### Handle ImageEmptyErr when Exporting Image Data

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/errors.md

Handle the 'image is empty' error when attempting to export data from an image wrapper where the underlying image is nil. This indicates an improperly initialized or corrupted image.

```go
masterImg := captData.GetMasterImage()
bytes, err := masterImg.ToBytes()
if err != nil && err.Error() == "image is empty" {
    log.Fatal("Image data is nil, cannot export")
}
```

--------------------------------

### Set Thumbnail Backgrounds

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Provide custom background images for the thumbnail. This allows for customized thumbnail backgrounds.

```go
builder.SetResources(click.WithThumbBackgrounds([]image.Image))
```

--------------------------------

### Aliased Module Import for Go Captcha V2

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Demonstrates importing the Go Captcha V2 module with an alias. This can help avoid naming conflicts in larger projects.

```go
import gocaptcha "github.com/wenlng/go-captcha/v2"

builder := gocaptcha.NewClickBuilder()
```

--------------------------------

### Component-Specific Imports for Go Captcha V2

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Illustrates importing specific CAPTCHA modules for better code organization. This approach is useful for modularity, allowing you to import only the necessary components.

```go
import (
    "github.com/wenlng/go-captcha/v2/click"
    "github.com/wenlng/go-captcha/v2/slide"
    "github.com/wenlng/go-captcha/v2/rotate"
    "github.com/wenlng/go-captcha/v2/base/option"
    "github.com/wenlng/go-captcha/v2/base/imagedata"
)

clickBuilder := click.NewBuilder()
slideBuilder := slide.NewBuilder()
rotateBuilder := rotate.NewBuilder()
```

--------------------------------

### Configure Click CAPTCHA Backgrounds

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Sets the available background images for the main CAPTCHA image. These images are used as the base for the challenge.

```go
click.WithBackgrounds([]image.Image{bgImage1, bgImage2})
```

--------------------------------

### Convert JPEG to Base64 String (with Quality and Data URI)

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/imagedata.md

Use ToBase64WithQuality to encode the JPEG image to Base64 with a specified quality and the data URI prefix. Quality levels are predefined.

```go
base64Str, err := jpegData.ToBase64WithQuality(option.QualityLevel2)
```

--------------------------------

### Generate Text CAPTCHA

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Create a text-mode CAPTCHA instance using `Make()` and then generate its data.

```go
textCaptcha := builder.Make()
captchaData, err := textCaptcha.Generate()
```

--------------------------------

### Set CAPTCHA Resources

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Configures the essential resources for the CAPTCHA, including characters, fonts, and background images. Generation will fail without these.

```go
builder.SetResources(
    click.WithChars(chars),
    click.WithFonts(fonts),
    click.WithBackgrounds(images),
)
```

--------------------------------

### Set Background Image Resources

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Use `slide.WithBackgrounds` to set the main image backgrounds for the captcha. Ensure images are valid.

```go
builder.SetResources(slide.WithBackgrounds(images))
```

--------------------------------

### Builder Make Methods

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/MANIFEST.txt

Methods on the Builder to create CAPTCHA instances with specific modes.

```APIDOC
## Builder.Make()

### Description
Creates a CAPTCHA instance using the builder's configuration.

### Method
`builder.Make()`

### Parameters
None

### Response
Returns a `Captcha` instance.

### Code Example
```go
captchaInstance := builder.Make()
```
```

```APIDOC
## Builder.MakeDragDrop()

### Description
Creates a CAPTCHA instance configured for drag-and-drop mode.

### Method
`builder.MakeDragDrop()`

### Parameters
None

### Response
Returns a `Captcha` instance.

### Code Example
```go
captchaInstance := builder.MakeDragDrop()
```
```

```APIDOC
## Builder.MakeShape()

### Description
Creates a CAPTCHA instance configured for shape-matching mode.

### Method
`builder.MakeShape()`

### Parameters
None

### Response
Returns a `Captcha` instance.

### Code Example
```go
captchaInstance := builder.MakeShape()
```
```

--------------------------------

### Configuration Options

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Options for customizing CAPTCHA generation using functional options pattern.

```APIDOC
## Configuration Options

Options are applied using the builder or SetOptions methods. All options use the functional option pattern.

### Main Image Options

#### WithImageSize()
Sets the main image dimensions. Default: 300x220.
```go
click.WithImageSize(option.Size{Width: 300, Height: 220})
```

#### WithRangeLen()
Sets the range for random character/shape count on main image.
```go
click.WithRangeLen(option.RangeVal{Min: 4, Max: 6})
```

#### WithRangeSize()
Sets the range for random content size on main image.
```go
click.WithRangeSize(option.RangeVal{Min: 20, Max: 30})
```

#### WithRangeAnglePos()
Sets the range for random rotation angles.
```go
click.WithRangeAnglePos([]option.RangeVal{
    {Min: -45, Max: 45},
    {Min: -30, Max: 30},
})
```

#### WithRangeColors()
Sets available text/shape colors. Max 255 colors.
```go
click.WithRangeColors([]string{"#FF0000", "#00FF00", "#0000FF"})
```

#### WithDisplayShadow()
Enables or disables shadow effects on content.
```go
click.WithDisplayShadow(true)
```

#### WithShadowColor()
Sets the shadow color in hex format.
```go
click.WithShadowColor("#000000")
```

#### WithShadowPoint()
Sets shadow offset position.
```go
click.WithShadowPoint(option.Point{X: 3, Y: 3})
```

#### WithImageAlpha()
Sets main image transparency (0.0 to 1.0).
```go
click.WithImageAlpha(0.8)
```

### Thumbnail Image Options

#### WithThumbImageSize()
Sets thumbnail dimensions. Default: 150x40.
```go
click.WithThumbImageSize(option.Size{Width: 150, Height: 40})
```

#### WithRangeVerifyLen()
Sets the range for verification content count on thumbnail. Max value must be ≤ rangeLen.Min.
```go
click.WithRangeVerifyLen(option.RangeVal{Min: 2, Max: 4})
```

#### WithDisabledRangeVerifyLen()
When true, thumbnail shows same content count as main image instead of random.
```go
click.WithDisabledRangeVerifyLen(true)
```

#### WithRangeThumbSize()
Sets the range for thumbnail content size.
```go
click.WithRangeThumbSize(option.RangeVal{Min: 14, Max: 20})
```

#### WithRangeThumbColors()
Sets available colors for thumbnail content. Max 255 colors.
```go
click.WithRangeThumbColors([]string{"#FFFFFF", "#F0F0F0"})
```

#### WithRangeThumbBgColors()
Sets available background colors for thumbnail. Max 255 colors.
```go
click.WithRangeThumbBgColors([]string{"#333333", "#444444"})
```

#### WithThumbBgDistort()
Sets thumbnail background distortion level (0-5). Constants: `DistortNone`, `DistortLevel1` through `DistortLevel5`.
```go
click.WithThumbBgDistort(option.DistortLevel3)
```

#### WithThumbBgCirclesNum()
Sets the number of decorative circles in thumbnail background.
```go
click.WithThumbBgCirclesNum(5)
```

#### WithThumbBgSlimLineNum()
Sets the number of decorative lines in thumbnail background.
```go
click.WithThumbBgSlimLineNum(3)
```

#### WithIsThumbNonDeformAbility()
When true, prevents thumbnail content from deforming.
```go
click.WithIsThumbNonDeformAbility(true)
```

#### WithUseShapeOriginalColor()
When true (shape mode only), uses the original image color instead of applying random colors.
```go
click.WithUseShapeOriginalColor(true)
```
```

--------------------------------

### Create Click CAPTCHA Builder

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Initializes a Click CAPTCHA builder with default or custom options. Use this to configure image size, character range, resources like fonts and backgrounds, and then generate text or shape mode CAPTCHAs.

```go
import (
    v2 "github.com/wenlng/go-captcha/v2"
    "github.com/wenlng/go-captcha/v2/base/option"
)

// Create builder with default options
builder := v2.NewClickBuilder()

// Or create builder with initial options
builder := v2.NewClickBuilder(
    click.WithImageSize(option.Size{Width: 300, Height: 220}),
    click.WithRangeLen(option.RangeVal{Min: 4, Max: 6}),
)

// Configure resources
builder.SetResources(
    click.WithChars([]string{"A", "B", "C"}),
    click.WithFonts([]*truetype.Font{font1}),
    click.WithBackgrounds([]image.Image{bgImage}),
)

// Create text mode CAPTCHA
textCaptcha := builder.Make()

// Or create shape mode CAPTCHA
shapeCaptcha := builder.MakeShape()

// Generate CAPTCHA data
captData, err := textCaptcha.Generate()
```

--------------------------------

### Generate Rotate CAPTCHA Instance

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/rotate.md

Use the `Make` method on the builder to generate a `rotate.Captcha` instance. This instance can then be used to generate CAPTCHA challenges.

```go
rotateCaptcha := builder.Make()
captchaData, err := rotateCaptcha.Generate()
```

--------------------------------

### Create New PNGImageData Instance

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/imagedata.md

Creates a new PNG image data instance from an existing image.Image object. This is the entry point for processing PNG images.

```go
func NewPNGImageData(img image.Image) PNGImageData
```

```go
import (
    "image"
    "github.com/wenlng/go-captcha/v2/base/imagedata"
)

pngData := imagedata.NewPNGImageData(myImage)
```

--------------------------------

### Configure Click CAPTCHA Fonts

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Sets the available TrueType fonts for rendering text in CAPTCHA challenges. Ensure font files are properly loaded.

```go
click.WithFonts([]*truetype.Font{font1, font2})
```

--------------------------------

### Set Thumbnail Image Size

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/configuration.md

Sets the dimensions of the thumbnail preview image. Minimum width is 50 pixels, minimum height is 20 pixels. Recommended dimensions are 120-200 width and 30-50 height.

```go
click.WithThumbImageSize(option.Size{Width: 150, Height: 40})
```

--------------------------------

### Retrieve CAPTCHA Options - Go

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/rotate.md

Retrieves the current configuration options for the CAPTCHA. Useful for inspecting or verifying settings.

```go
opts := capt.GetOptions()
squareSize := opts.GetImageSize()
```

--------------------------------

### Configure Thumbnail Random Colors

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Set a range of random colors for the thumbnail content. This allows for varied visual appearances of the thumbnail.

```go
click.NewBuilder(click.WithRangeThumbColors([]string))
```

--------------------------------

### Configure Puzzle Piece Size Range

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Sets the minimum and maximum size for randomly generated puzzle pieces. This affects the visual difficulty of the puzzle.

```go
slide.WithRangeGraphSize(option.RangeVal{Min: 40, Max: 80})
```

--------------------------------

### Prevent ImageEmptyErr by Verifying Generation

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/errors.md

Prevent the 'image is empty' error by ensuring that `capt.Generate()` has succeeded before accessing images. This guarantees the image data is properly initialized.

```go
// Always verify CaptchaData.Generate() succeeded before accessing images
captData, err := capt.Generate()
if err != nil {
    log.Fatal("Generate failed:", err)
}
// Safe to access images now
img := captData.GetMasterImage()
```

--------------------------------

### Set Main Image Backgrounds

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Provide custom background images to be used for the main captcha. This allows for varied background designs.

```go
builder.SetResources(click.WithBackgrounds([]image.Image))
```

--------------------------------

### WithBackgrounds()

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Sets the available background images for the main CAPTCHA image. It takes a slice of image.Image objects.

```APIDOC
## WithBackgrounds()

### Description
Sets available background images for main image.

### Method Signature
```go
click.WithBackgrounds([]image.Image{bgImage1, bgImage2})
```

### Parameters
* **backgrounds** ([]image.Image) - Required - A slice of image.Image objects to be used as backgrounds.
```

--------------------------------

### Create Rotate CAPTCHA Builder

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Initializes a Rotate CAPTCHA builder with options for image square size and angle range. Configure background images and then generate the CAPTCHA instance to produce data including block, master, and thumbnail images.

```go
import (
    v2 "github.com/wenlng/go-captcha/v2"
    "github.com/wenlng/go-captcha/v2/base/option"
)

// Create builder
builder := v2.NewRotateBuilder(
    rotate.WithImageSquareSize(220),
    rotate.WithRangeAnglePos([]option.RangeVal{
        {Min: 0, Max: 360},
    }),
)

// Configure resources
builder.SetResources(
    rotate.WithImages([]image.Image{bgImage1, bgImage2}),
)

// Create CAPTCHA instance
rotateCaptcha := builder.Make()

// Generate CAPTCHA data
captData, err := rotateCaptcha.Generate()
if err != nil {
    log.Fatal(err)
}

// Access generated data
block := captData.GetData()
masterImg := captData.GetMasterImage()
thumbImg := captData.GetThumbImage()
```

--------------------------------

### Access Captcha Options Interface

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/types.md

General pattern for querying current settings from any Captcha Options struct. Use the GetOptions() method to retrieve the options interface.

```go
// Example pattern for any Captcha instance
opts := capt.GetOptions()
imageSize := opts.GetImageSize()
```

--------------------------------

### Set Puzzle Piece Graphics

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Use `slide.WithGraphImages` to set the graphics for the puzzle piece. Ensure images are valid.

```go
builder.SetResources(slide.WithGraphImages(images))
```

--------------------------------

### Set Thumbnail Content Size Range

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Configures the range (minimum and maximum) for the size of content elements on the thumbnail image. This uses a functional option pattern.

```go
click.WithRangeThumbSize(option.RangeVal{Min: 14, Max: 20})

```

--------------------------------

### NewBuilder()

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Creates a new Builder instance for constructing Click CAPTCHA instances. It accepts optional configuration options.

```APIDOC
## Function: NewBuilder()

```go
func NewBuilder(opts ...click.Option) click.Builder
```

Creates a new Builder instance for constructing Click CAPTCHA instances. It accepts optional configuration options.

### Parameters
#### Options
- **opts** (`...click.Option`) - Optional - Optional configuration options to apply during builder creation

### Returns
- `click.Builder` interface

### Example

```go
import "github.com/wenlng/go-captcha/v2/click"

builder := click.NewBuilder(
    click.WithImageSize(option.Size{Width: 300, Height: 220}),
    click.WithRangeLen(option.RangeVal{Min: 4, Max: 6}),
)
```
```

--------------------------------

### Builder Instance Creation

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/MANIFEST.txt

Creates a CAPTCHA instance from a builder. This is a general-purpose method for generating CAPTCHA challenges.

```go
func (b *Builder) Make() (*Captcha, error)

```

--------------------------------

### Generate Basic Slide CAPTCHA

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Use the Make method on a Slide CAPTCHA builder to generate a basic CAPTCHA instance. This instance supports a puzzle piece that slides along a fixed Y-axis.

```go
basicSlide := builder.Make()
captchaData, err := basicSlide.Generate()
```

--------------------------------

### Set Background Images for Captcha

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/errors.md

Ensure background images are set using `click.WithBackgrounds` when the 'no background image' error occurs. This requires a slice of `image.Image`.

```go
bgImages := []image.Image{img1, img2}
builder.SetResources(click.WithBackgrounds(bgImages))
```

--------------------------------

### Thumbnail Image Options

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/rotate.md

Configuration options specific to thumbnail image generation, including size variations and transparency.

```APIDOC
## WithRangeThumbImageSquareSize()

### Description
Sets the available sizes for the thumbnail image (square). The thumbnail will be randomly selected from this list of sizes.

### Example
```go
rotate.WithRangeThumbImageSquareSize([]int{80, 100, 120})
```
```

```APIDOC
## WithThumbImageAlpha()

### Description
Sets the thumbnail image transparency (0.0 to 1.0).

### Example
```go
rotate.WithThumbImageAlpha(0.9)
```
```

--------------------------------

### Set Slide Graph Images

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Sets the puzzle piece graphics, including the overlay, shadow, and mask images. This is a required configuration.

```go
graphImages := []*slide.GraphImage{
    {
        OverlayImage: tileImage,
        ShadowImage:  shadowImage,
        MaskImage:    maskImage,
    },
}
slide.WithGraphImages(graphImages)
```

--------------------------------

### Handle EmptyBackgroundImageErr in Go

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/errors.md

Check for the specific 'no background image' error when generating CAPTCHA data. This ensures your application fails gracefully if background images are not configured.

```go
captData, err := capt.Generate()
if err != nil && err.Error() == "no background image" {
    log.Fatal("Must provide at least one background image")
}
```

--------------------------------

### Captcha.GetOptions()

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/rotate.md

Retrieves the current configuration options for the CAPTCHA generator. This allows inspection of settings like image size.

```APIDOC
## Captcha.GetOptions()

### Description
Retrieves the current configuration options.

### Method
`Captcha.GetOptions()`

### Returns
- `*rotate.Options`: Pointer to the current rotation options.

### Example
```go
opts := capt.GetOptions()
squareSize := opts.GetImageSize()
```
```

--------------------------------

### Create CAPTCHA Instance

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/v2-module.md

Creates an immutable CAPTCHA instance from the configured builder. The builder can be reused to create multiple instances.

```go
capt := builder.Make()
```

--------------------------------

### Retrieve Slide Captcha Options

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Retrieves the current configuration options for the captcha. Use this to inspect or verify settings like image size.

```go
func (c *captcha) GetOptions() *slide.Options
```

```go
opts := capt.GetOptions()
imageSize := opts.GetImageSize()
```

--------------------------------

### Builder.Make()

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Generates a basic-mode Slide CAPTCHA instance where the puzzle piece slides along a fixed Y-axis.

```APIDOC
## Method: Builder.Make()

### Description
Generates a basic-mode Slide CAPTCHA instance where the puzzle piece slides along a fixed Y-axis.

### Signature
```go
func (b *builder) Make() slide.Captcha
```

### Returns
- `slide.Captcha`: An interface for a basic slide mode CAPTCHA.

### Example
```go
basicSlide := builder.Make()
captchaData, err := basicSlide.Generate()
```
```

--------------------------------

### Builder.SetResources()

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Sets or appends resources to the builder, such as characters, fonts, and background images.

```APIDOC
## Method: Builder.SetResources()

```go
func (b *builder) SetResources(resources ...click.Resource)
```

Sets or appends resources to the builder, such as characters, fonts, and background images.

### Parameters
#### Resources
- **resources** (`...click.Resource`) - Optional - Resource configuration functions

### Example

```go
builder.SetResources(
    click.WithChars([]string{"A", "B", "C", "1", "2"}),
    click.WithFonts([]*truetype.Font{font1}),
    click.WithBackgrounds([]image.Image{bgImage}),
)
```
```

--------------------------------

### NewBuilder()

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Creates a new Builder instance for constructing Slide CAPTCHA instances. Accepts optional configuration options.

```APIDOC
## Function: NewBuilder()

### Description
Creates a new Builder instance for constructing Slide CAPTCHA instances. Accepts optional configuration options.

### Signature
```go
func NewBuilder(opts ...slide.Option) slide.Builder
```

### Parameters
#### Options (`opts`)
- `...slide.Option`: Optional configuration options to apply during builder creation.

### Returns
- `slide.Builder`: An interface for building Slide CAPTCHAs.

### Example
```go
import "github.com/wenlng/go-captcha/v2/slide"

builder := slide.NewBuilder(
    slide.WithImageSize(option.Size{Width: 300, Height: 220}),
)
```
```

--------------------------------

### Set Number of Lines in Thumbnail Background

Source: https://github.com/wenlng/go-captcha/blob/master/README.md

Specify the number of lines to be included in the thumbnail's background. This contributes to the background's design and complexity.

```go
click.NewBuilder(click.WithThumbBgSlimLineNum(int))
```

--------------------------------

### Configure Click CAPTCHA Characters

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/click.md

Sets the available characters for text-based CAPTCHA challenges. Use this when text mode is enabled.

```go
click.WithChars([]string{"A", "B", "C", "D", "E", "1", "2", "3"})
```

--------------------------------

### Set Slide Backgrounds

Source: https://github.com/wenlng/go-captcha/blob/master/_autodocs/api-reference/slide.md

Sets the available background images for the main captcha image. This is a required configuration.

```go
slide.WithBackgrounds([]image.Image{bgImage1, bgImage2})
```
Tokens:
Raw