# ಚಿತ್ರವನ್ನು ಹಿಡಿ - ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈ

ಪಾಠದ ಈ ಭಾಗದಲ್ಲಿ, ನೀವು ನಿಮ್ಮ ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈಸಿಗೆ ಕ್ಯಾಮೆರಾ ಸೆನ್ಸರ್ ಸೇರಿಸಿ, ಅದರಿಂದ ಚಿತ್ರಗಳನ್ನು ಓದಲು ಸಿದ್ಧಪಡಿಸುವಿರಿ.

## ಹಾರ್ಡ್‌ವೇರ್

ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈಸಿಗೆ ಕ್ಯಾಮೆರಾ ಬೇಕಾಗುತ್ತದೆ.

ನೀವು ಬಳಸಬಲಿರುವ ಕ್ಯಾಮೆರಾ [ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈ ಕ್ಯಾಮೆರಾ ಮೋ듯ಲ್](https://www.raspberrypi.org/products/camera-module-v2/) ಆಗಿದೆ. ಈ ಕ್ಯಾಮೆರಾ ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈಗೆ ಕೆಲಸ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲ್ಪಟ್ಟಿದ್ದು, ಪೈಯಲ್ಲಿ ವಿಶೇಷ ಸಂಪರ್ಕಕ ಮೂಲಕ ಸಂಪರ್ಕಗೊಳ್ಳುತ್ತದೆ.

> 💁 ಈ ಕ್ಯಾಮೆರಾ [ಕ್ಯಾಮೆರಾ ಸೀರಿಯಲ್ ಇಂಟರ್ಫೇಸ್, ಮೊಬೈಲ್ ಇಂಡಸ್ಟ್ರಿ ಪ್ರೊಸೆಸರ್ ಇಂಟರ್ಫೇಸ್ ಅಲೈನ್ಸ್‌ನ ಪ್ರೋಟೋಕಾಲ್](https://wikipedia.org/wiki/Camera_Serial_Interface) ಅನ್ನು ಉಪಯೋಗಿಸುತ್ತದೆ, ಅದನ್ನು MIPI-CSI ಎಂದು ಕರೆಯುತ್ತಾರೆ. ಇದು ಚಿತ್ರಗಳನ್ನು ಕಳುಹಿಸಲು ವಿಶೇಷ ಪ್ರೋಟೋಕಾಲ್.

## ಕ್ಯಾಮೆರಾವನ್ನು ಸಂಪರ್ಕಿಸಿ

ಕ್ಯಾಮೆರಾವನ್ನು ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈಸಿಗೆ ರಿಬನ್ ಕೇಬಲ್ ಬಳಸಿ ಸಂಪರ್ಕಿಸಬಹುದು.

### ಕಾರ್ಯ - ಕ್ಯಾಮೆರಾ ಸಂಪರ್ಕಿಸಿ

![ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈ ಕ್ಯಾಮೆರಾ](../../../../../translated_images/kn/pi-camera-module.4278753c31bd6e75.webp)

1. ಪೈಯನ್ನು ಪವರ್ ಆಫ್ ಮಾಡಿ.

1. ಕ್ಯಾಮೆರಾ ಜೊತೆಗೆ ಬರುವ ರಿಬನ್ ಕೇಬಲ್ ಅನ್ನು ಕ್ಯಾಮೆರಾಗೆ ಸಂಪರ್ಕಿಸಿ. ಇದಕ್ಕಾಗಿ, ಧೀರೆ ಧೀರೆ ಪ್ಲಾಸ್ಟಿಕ್ ಕ್ಲಿಪ್ ಅನ್ನು ಹಿಡಿದು ಸ್ವಲ್ಪ ಹೊರಗೆ ಎಳೆಯಿರಿ, ನಂತರ ಕೇಬಲ್ ಅನ್ನು ಸಾಕೆಟ್‌ಗೆ ಜಾರಿ ಹಾಕಿ, ನೀಲಿ ಬದಿಯು ಲೆನ್ಸ್‌ನಿಂದ ದೂರವಿರಬೇಕು, ಲೆನ್ಸ್ ಕಡೆಗೆ ಲೋಹದ ಪಿನ್ ಸ್ಟ್ರಿಪ್ ಗಳಿರುವ ಭಾಗ ಇರಬೇಕು. ಸಂಪೂರ್ಣವಾಗಿ ಒಳಗೆ ಹೋಗಿದ ನಂತರ, કಲ್ಲಿ ಕಪ್ಪು ಪ್ಲಾಸ್ಟಿಕ್ ಕ್ಲಿಪ್ ಅನ್ನು ಹಿಂದಕ್ಕೆ ತಳ್ಳಿರಿ.

    [ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈ ಕ್ಯಾಮೆರಾ ಮೋ듯ಲ್ ಕಿತ್ತಾಟ ಉಪನ್ಯಾಸ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ](https://projects.raspberrypi.org/en/projects/getting-started-with-picamera/2) ಕ್ಲಿಪ್ ತೆರೆಯುವುದು ಮತ್ತು ಕೇಬಲ್ ಅಳವಡಿಸುವುದರ್ಯುವೊಂದು ಚಲನಚಿತ್ರವನ್ನು ನೀವು ನೋಡಬಹುದು.

    ![ಕ್ಯಾಮೆರಾ ಮೋ듯ಲಿನಲ್ಲಿ ರಿಬನ್ ಕೇಬಲ್ ಅಳವಡಿಸಲಾಗಿದೆ](../../../../../translated_images/kn/pi-camera-ribbon-cable.0bf82acd251611c2.webp)

1. Grove Base Hat ಅನ್ನು ಪೈಯಿಂದ ತೆಗೆದುಹಾಕಿ.

1. Grove Base Hat ನಲ್ಲಿ ಇರುವ ಕ್ಯಾಮೆರಾ ಸ್ಲಾಟ್ ಮೂಲಕ ರಿಬನ್ ಕೇಬಲ್ ತ.pass ಮಾಡಿ. ಕೇಬಲ್‌ನ ನೀಲಿ ಬದಿಯು **A0**, **A1** ಇತ್ಯಾದಿ ಅನಾಲಾಗ್ ಪೋರ್ಟ್ಗಳ ಕಡೆ ಮುಖಮಾಡಿದ್ದೇ ಇರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

    ![Grove Base Hat ನಲ್ಲಿ ರಿಬನ್ ಕೇಬಲ್ ನಿಪಾದಿಸಲಾಗುತ್ತಿದೆ](../../../../../translated_images/kn/grove-base-hat-ribbon-cable.501fed202fcf73b1.webp)

1. ಪೈಯಲ್ಲಿ ಇರುವ ಕ್ಯಾಮೆರಾ ಪೋರ್ಟ್‌ಗೆ ರಿಬನ್ ಕೇಬಲ್ ಅಳವಡಿಸಿ. ಮರುಬಾರಿಯಾಗಿ, ಕಪ್ಪು ಪ್ಲಾಸ್ಟಿಕ್ ಕ್ಲಿಪ್ ಅನ್ನು ಎಳೆಯಿರಿ, ಕೇಬಲ್ ಸೇರಿಸಿ, ನಂತರ ಕ್ಲಿಪ್ ಅನ್ನು ಕೂಡಿಸಿ. ಕೇಬಲ್‌ನ ನೀಲಿ ಬದಿಯು USB ಮತ್ತು ಇಥರ್ನೆಟ್ ಪೋರ್ಟ್ಗಳ ಕಡೆ ಮುಖಮಾಡಿರಬೇಕು.

    ![ಪೈಯಲ್ಲಿನ ಕ್ಯಾಮೆರಾ ಸಾಕೆಟ್‌ಗೆ ರಿಬನ್ ಕೇಬಲ್ ಸಂಪರ್ಕಿಸಲಾಗಿದೆ](../../../../../translated_images/kn/pi-camera-socket-ribbon-cable.a18309920b118009.webp)

1. Grove Base Hat ಅನ್ನು ಮತ್ತೆ ಅಳವಡಿಸಿ.

## ಕ್ಯಾಮೆರಾವನ್ನು ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಿ

ಈಗ ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈಗೆ [PiCamera](https://pypi.org/project/picamera/) ಪೈಥಾನ್ ಲೈಬ್ರೆರಿಯನ್ನು ಬಳಸಿ ಕ್ಯಾಮೆರಾ ಉಪಯೋಗಿಸಲು ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಬಹುದಾಗಿದೆ.

### ಕಾರ್ಯ - ಲೆಗಸಿ ಕ್ಯಾಮೆರಾ ಮೋಡ್ ಸಕ್ರಿಯಗೊಳಿಸಿ

ದुರ್ಭಾಗ್ಯವಶಾತ್, ರಾಸ್ಪ್ಬೆರ್ರಿ ಪೈ OS ಬ್ಲ್ಸೈ ಬಿಡುಗಡೆ ನಂತರ, ಕ್ಯಾಮೆರಾ ಸಾಫ್ಟ್‌ವೇರ್ ಬದಲಾಗಿದ್ದು, ಡಿಫಾಲ್ಟ್ ಆಗಿ PiCamera ಈಗ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ. ಬದಲು PiCamera2 ಎಂಬ ಹೊಸದೊಂದು ಸಿದ್ಧವಾಗುತ್ತಿದ್ದು, ಅದು ಇನ್ನೂ ಉಪಯೋಗಕ್ಕೆ ಸಿದ್ಧವಿಲ್ಲ.

ಇದೀಗ, ನಿಮ್ಮ ಪೈಯನ್ನು ಲೆಗಸಿ ಕ್ಯಾಮೆರಾ ಮೋಡ್‌ಗೆ ಸೆಟ್ ಮಾಡಿ PiCamera ಕೆಲಸ ಮಾಡಲು ಅವಕಾಶ ನೀಡಬಹುದು. ಕ್ಯಾಮೆರಾ ಸಾಕೆಟ್ ಡಿಫಾಲ್ಟ್ ಆಗಿ ನಿಷ್ಕ್ರಿಯವಾಗಿದ್ದು, ಲೆಗಸಿ ಕ್ಯಾಮೆರಾ ಸಾಫ್ಟ್‌ವೇರ್ ಸಕ್ರಿಯ ಮಾಡಿದಾಗಲೇ ಸಾಕೆಟ್ ಸಕ್ರಿಯವಾಗುತ್ತದೆ.

1. ಪೈಯನ್ನು ಪವರ್ ಆನ್ ಮಾಡಿ ಮತ್ತು ಬೂಟ್ ಆಗುವದಕ್ಕೂ ಕಾಯಿರಿ.

1. ತಕ್ಷಣವೇ VS ಕೋಡ್ ಅವರನ್ನು ಪ್ರಾರಂಭಿಸಿ, ಪೈಯಲ್ಲಿ ನೇರವಾಗಿ ಅಥವಾ ರಿಮೋಟ್ SSH ವಿಸ್ತರಣೆಯ ಮೂಲಕ ಸಂಪರ್ಕ ಹೊಂದಿ.

1. ನಿಮ್ಮ ಟರ್ಮಿನಲ್‌ನಿಂದ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ನಿರ್ವಹಿಸಿ:

    ```sh
    sudo raspi-config nonint do_legacy 0
    sudo reboot
    ```

    ಇದು ಲೆಗಸಿ ಕ್ಯಾಮೆರಾ ಸಾಫ್ಟ್‌ವೇರ್ ಸಕ್ರಿಯಗೊಳಿಸುವ ಸೆಟ್ಟಿಂಗನ್ನು ಟಾಗ್ಲ್ ಮಾಡುತ್ತದೆ, ನಂತರ ಆ ಸೆಟ್ಟಿಂಗಿನ ಪರಿಣಾಮಕ್ಕಾಗಿ ಪೈಯನ್ನು ಮರುಬೂಟ್ ಮಾಡುತ್ತದೆ.

1. ಪೈ ಮರುಬೂಟ್ ಆಗಿದಾದ ಮೇಲೆ, ಮತ್ತೆ VS ಕೋಡ್ ಪ್ರಾರಂಭಿಸಿ.

### ಕಾರ್ಯ - ಕ್ಯಾಮೆರಾವನ್ನು ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಿ

ಪರಿಕರವನ್ನು ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಿ.

1. ಟರ್ಮಿನಲ್‌ನಿಂದ, `pi` ಬಳಕೆದಾರನ ಮನೆ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ `fruit-quality-detector` ಎಂಬ ಹೊಸ ಫೋಲ್ಡರ್ ರಚಿಸಿ. ಆ ಫೋಲ್ಡರ್ ಒಳಗೆ `app.py` ಎಂಬ ಫೈಲ್ ರಚಿಸಿ.

1. ಈ ಫೋಲ್ಡರ್ ಅನ್ನು VS ಕೋಡ್‌ನಲ್ಲಿ ತೆರೆಯಿರಿ.

1. ಕ್ಯಾಮೆರಾ ಜೊತೆಗೆ ಸಂವಾದ ಮಾಡಲು, PiCamera ಪೈಥಾನ್ ಲೈಬ್ರೇರಿಯನ್ನು ಉಪಯೋಗಿಸಬಹುದು. ಅದಕ್ಕಾಗಿ ಪಿಪ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಕೆಳಗಿನ ಆಜ್ಞೆಯಿಂದ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ:

    ```sh
    pip3 install picamera
    ```

1. ನಿಮ್ಮ `app.py` ಫೈಲ್‌ಗೆ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```python
    import io
    import time
    from picamera import PiCamera
    ```

    ಈ ಕೋಡ್ ಕೆಲವು ಲೈಬ್ರೆರಿಗಳನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡುತ್ತದೆ, PiCamera ಲೈಬ್ರೇರಿ ಸಹಿತ.

1. ಕ್ಯಾಮೆರಾವನ್ನು ಆರಂಭಿಸಲು ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```python
    camera = PiCamera()
    camera.resolution = (640, 480)
    camera.rotation = 0
    
    time.sleep(2)
    ```

    ಈ ಕೋಡ್ PiCamera ವಸ್ತುವನ್ನು ಸೃಷ್ಟಿಸಿ, ರೆಸಲ್ಯೂಶನ್ 640x480 ಆಗಿ ಸೆಟ್ ಮಾಡುತ್ತದೆ. ಹೆಚ್ಚು ರೆಸಲ್ಯೂಶನ್‌ಗಳು (ಅಂದರೆ 3280x2464 ವರೆಗೆ) ಬೆಂಬಲಿತವಾಗಿದ್ದರೂ, ಚಿತ್ರ ವರ್ಗೀಕರಿಸುವುದು 227x227 ಗಾತ್ರದ ಚಿತ್ರಗಳ ಮೇಲೆ ಕೆಲಸ ಮಾಡುವುದರಿಂದ ದೊಡ್ಡ ಚಿತ್ರಗಳನ್ನು ಹಿಡಿಯಬೇಕಾಗಿಲ್ಲ.

    `camera.rotation = 0` ಸಾಲು ಚಿತ್ರದ ರೋಟೇಷನ್ ನ್ನು ನಿಶ್ಚಿತಗೊಳಿಸುತ್ತದೆ. ರಿಬನ್ ಕೇಬಲ್ ಕ್ಯಾಮೆರಾ ಕೆಳಭಾಗಕ್ಕೆ ಬರುತ್ತದೆ, ಆದರೆ ನೀವು ನಿಮ್ಮ ಕ್ಯಾಮೆರాను ಆಂಗೀಕರಿಸಬೇಕಾದ ವಸ್ತುವಿಗೆ ಸುಲಭವಾಗಿ ಮುಟ್ಟಲು ತಿರುಗಿಸಿದ್ದರೆ, ಈ ಸಾಲನ್ನು ರೋಟೇಷನ್ ಡಿಗ್ರಿಗಳ ಸಂಖ್ಯೆ ಮೂಲಕ ಬದಲಾಯಿಸಬಹುದು.

    ![ಕ್ಯಾಮೆರಾ ಕೆಳಭಾಗದಿಂದ ಹ hangingಗಿದಿರುವುದು](../../../../../translated_images/kn/pi-camera-upside-down.5376961ba3145988.webp)

    ಉದಾಹರಣೆಗೆ, ನೀವು ರಿಬನ್ ಕೇಬಲ್ ಅನ್ನು ಯಾವೋ ವಸ್ತುವಿನ ಮೇಲೆ ಹಾಕಿ ಕ್ಯಾಮೆರಾ ಮೇಲ್ಭಾಗದಲ್ಲಿದ್ದಾಗ, ಇದನ್ನು 180 ರೋಟೇಷನ್ ಆಗಿ ಸೆಟ್ ಮಾಡಿ:

    ```python
    camera.rotation = 180
    ```

    ಕ್ಯಾಮೆರಾ ಪ್ರಾರಂಭಿಸಲು ಕೆಲವು ಸೆಕೆಂಡುಗಳು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ `time.sleep(2)` ಇದೆ.

1. ಚಿತ್ರವನ್ನು ಬೈನರಿ ಡೇಟಾ ರೂಪದಲ್ಲಿ ಸೆರೆಹಿಡಿಯಲು ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```python
    image = io.BytesIO()
    camera.capture(image, 'jpeg')
    image.seek(0)
    ```

    ಇದು `BytesIO` ವಸ್ತುವನ್ನು ಸೃಷ್ಟಿಸಿ ಬೈನರಿ ಡೇಟಾ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಚಿತ್ರವನ್ನು ಕ್ಯಾಮೆರಾರಿಂದ JPEG ಫೈಲ್ ಆಗಿ ಓದಿ ಈ ವಸ್ತುವಿನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಈ ವಸ್ತುವಿಗೆ ಒಂದು ಸ್ಥಾನ ಸೂಚಕವಿದ್ದು, ಅದು ಡೇಟಾದಲ್ಲಿ ಯಾವ ಸ್ಥಳದಲ್ಲಿದೆ ತಿಳಿದುಕೊಳ್ಳಲು ಸಹಾಯಮಾಡುತ್ತದೆ ಹಾಗಾಗಿ ಹೆಚ್ಚು ಡೇಟಾವನ್ನು ಕೊನೆಗೆ ಬರೆಯಬಹುದು. `image.seek(0)` ಇದೇ ಸ್ಥಾನವನ್ನು ಪ್ರಾರಂಭಕ್ಕೆ ಮರಳಿಸುತ್ತದೆ, ಹೀಗಾಗಿ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ನಂತರ ಓದಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

1. ಇದರ ಕೆಳಗೆ ಚಿತ್ರವನ್ನು ಫೈಲ್‌ಗೆ ಉಳಿಸುವುದಕ್ಕೆ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```python
    with open('image.jpg', 'wb') as image_file:
        image_file.write(image.read())
    ```

    ಇದು `image.jpg` ಎಂಬ ಫೈಲ್ ಅನ್ನು ಬರೆಯಲು ತೆರೆಯುತ್ತ ಮತ್ತು `BytesIO` ವಸ್ತುವಿನ ಎಲ್ಲಾ ಡೇಟಾಗಳನ್ನು ಓದಿ ಆ ಫೈಲಿಗೆ ಬರೆದಿಡುತ್ತದೆ.

    > 💁 ನೀವು ಚಿತ್ರವನ್ನು ನೇರವಾಗಿ ಫೈಲ್‌ಗೆ ಸೆರೆಹಿಡಿಯಬಹುದು `BytesIO` ವಸ್ತುವಿನ ಬದಲು, ಅದಕ್ಕಾಗಿ ಫೈಲ್‌ನಾಮವನ್ನು `camera.capture` ಕರೆಗೂಡು. ಆದರೆ `BytesIO` ವಸ್ತುವನ್ನು ಬಳಸಿ ಇಂತಹ ಕಾರಣ ಏನೆಂದರೆ, ಈ ಪಾಠದ ಮುಂದಿನ ಭಾಗದಲ್ಲಿ ನೀವು ಚಿತ್ರವನ್ನು ಚಿತ್ರ ವರ್ಗೀಕರಿಸುವವರಿಗೆ ಕಳುಹಿಸಬಹುದು.

1. ಕ್ಯಾಮೆರಾ ಯಾವುದಾದರೂ ವಸ್ತುವಿನ ಮೇಲೆ ತೋರಿಸಿ ಈ ಕೋಡ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡಿ.

1. `image.jpg` ಎಂಬ ಫೈಲ್ ಇದೀಗ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಉಳಿಯುವದೆ. ಈ ಫೈಲ್ ಅನ್ನು VS ಕೋಡ್ ಎಕ್ಸ್ಪ್ಲೋರರ್‌ನಲ್ಲಿ ನೋಡಿ. ಚಿತ್ರವನ್ನು ನೋಡಲು ಫೈಲ್ ಆಯ್ಕೆಮಾಡಿ. ರೋಟೇಷನ್ ಬೇಕಾದರೆ, `camera.rotation = 0` ಸಾಲನ್ನು ತಿದ್ದು ಮತ್ತು ಮತ್ತೊಂದು ಚಿತ್ರ ತೆಗೆದುಕೊಳ್ಳಿ.

> 💁 ಈ ಕೋಡ್ [code-camera/pi](../../../../../4-manufacturing/lessons/2-check-fruit-from-device/code-camera/pi) ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ದೊರಕುತ್ತದೆ.

😀 ನಿಮ್ಮ ಕ್ಯಾಮೆರಾ ಪ್ರೋಗ್ರಾಮ್ ಯಶಸ್ವಿಯಾಗಿ ಮುಗಿದಿದೆ!

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ತಿರಸ್ಕರಣೆ**:
ಈ ದಸ್ತಾವೇಜು AI ಭಾಷಾಂತರ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಭಾಷಾಂತರಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಗಾಗಿ ಪ್ರಯತ್ನಿಸುವಾಗ, ಸ್ವಯಂಚಾಲಿತ ಭಾಷಾಂತರಗಳಲ್ಲಿ ದುರುಪಯೋಗಗಳು ಅಥವಾ ತಪ್ಪுகள் ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿನ ಮೂಲ ದಸ್ತಾವೇಜು ಪ್ರಧಾನ ಪ್ರಾಮಾಣಿಕ ಮೂಲ ಎಂದು ಪರಿಗಣಿಸಲಾಗಬೇಕು. ಮುಖ್ಯ ಮಾಹಿತಿ ಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಭಾಷಾಂತರವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಭಾಷಾಂತರ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥೈಸಿಕೊಳ್ಳುವಿಕೆಗಳಿಗೆ ನಾವು ಜವಾಬ್ದಾರರಾಗಿದ್ದೇವೆ ಎಂದು ಪರಿಗಣಿಸುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->